linkedin-secret-sauce 0.3.29 → 0.5.0

package/dist/cookie-pool.d.ts

@@ -1,4 +1,4 @@
-import type { LinkedInCookie } from './types';
+import type { LinkedInCookie } from "./types";
 interface AccountEntry {
     accountId: string;
     cookies: LinkedInCookie[];

package/dist/cookie-pool.js

@@ -74,7 +74,7 @@ function nowSec() {
     return Math.floor(Date.now() / 1000);
 }
 function toEpochSeconds(v) {
-    if (typeof v !== 'number')
+    if (typeof v !== "number")
         return undefined;
     if (!Number.isFinite(v) || v <= 0)
         return undefined;
@@ -82,7 +82,7 @@ function toEpochSeconds(v) {
     return v > 1e10 ? Math.floor(v / 1000) : Math.floor(v);
 }
 function isExpired(entry) {
-    const jsession = entry.cookies.find(c => String(c.name).toUpperCase() === 'JSESSIONID');
+    const jsession = entry.cookies.find((c) => String(c.name).toUpperCase() === "JSESSIONID");
     const jsExp = toEpochSeconds(jsession?.expires);
     if (jsExp && jsExp < nowSec())
         return true;
@@ -110,10 +110,10 @@ async function ensureInitialized() {
     }
     poolState.rrIndex = 0;
     poolState.initialized = true;
-    (0, logger_1.log)('info', 'cookiePool.initialized', { count: accounts.length });
+    (0, logger_1.log)("info", "cookiePool.initialized", { count: accounts.length });
     // Start lightweight periodic refresh (guard against duplicate timers)
-    if (!poolState.refreshTimer && process.env.NODE_ENV !== 'test') {
-        const interval = Math.max(60_000, ((0, config_1.getConfig)().cookieRefreshInterval ?? 15 * 60 * 1000));
+    if (!poolState.refreshTimer && process.env.NODE_ENV !== "test") {
+        const interval = Math.max(60_000, (0, config_1.getConfig)().cookieRefreshInterval ?? 15 * 60 * 1000);
         poolState.refreshTimer = setInterval(async () => {
             try {
                 const refreshed = await (0, cosiall_client_1.fetchCookiesFromCosiall)();
@@ -133,21 +133,36 @@ async function ensureInitialized() {
                 }
                 poolState.accounts = newMap;
                 poolState.order = newOrder;
-                (0, logger_1.log)('info', 'cookiePool.refreshed', { count: refreshed.length });
+                (0, logger_1.log)("info", "cookiePool.refreshed", { count: refreshed.length });
             }
             catch (e) {
                 const err = e;
-                (0, logger_1.log)('warn', 'cookiePool.refreshFailed', { error: err?.message });
+                (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', {
+                    const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require("./utils/sentry")));
+                    reportWarningToSentry("Cookie refresh failed", {
                         error: err?.message,
-                        tags: { component: 'cookie-pool', severity: 'medium' },
+                        tags: { component: "cookie-pool", severity: "medium" },
                     });
                 }
                 catch { }
             }
+            // Cleanup expired sessions to prevent memory leaks in long-running processes
+            const now = Date.now();
+            let expiredCount = 0;
+            for (const [sessionId, session] of sessionAccountMap.entries()) {
+                if (now > session.expiresAt) {
+                    sessionAccountMap.delete(sessionId);
+                    expiredCount++;
+                }
+            }
+            if (expiredCount > 0) {
+                (0, logger_1.log)("debug", "cookiePool.sessionCleanup", {
+                    expiredSessions: expiredCount,
+                    remainingSessions: sessionAccountMap.size,
+                });
+            }
         }, interval);
     }
 }
@@ -171,15 +186,15 @@ function getCookiePoolHealth() {
     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,
+        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', {});
+        (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();
@@ -198,11 +213,11 @@ async function forceRefreshCookies() {
         poolState.accounts = newMap;
         poolState.order = newOrder;
         poolState.consecutiveMassFailures = 0; // Reset counter
-        (0, logger_1.log)('info', 'cookiePool.forceRefreshed', { count: refreshed.length });
+        (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 });
+        (0, logger_1.log)("error", "cookiePool.forceRefreshFailed", { error: err?.message });
         throw e;
     }
 }
@@ -218,7 +233,9 @@ function getAccountForSession(sessionId) {
     }
     // Check if account is still healthy
     const entry = poolState.accounts.get(session.accountId);
-    if (!entry || isExpired(entry) || entry.failures >= getSettings().maxFailures) {
+    if (!entry ||
+        isExpired(entry) ||
+        entry.failures >= getSettings().maxFailures) {
         sessionAccountMap.delete(sessionId);
         return undefined;
     }
@@ -228,13 +245,13 @@ function setAccountForSession(sessionId, accountId) {
     sessionAccountMap.set(sessionId, {
         accountId,
         lastUsedAt: Date.now(),
-        expiresAt: Date.now() + (30 * 60 * 1000), // 30 minutes
+        expiresAt: Date.now() + 30 * 60 * 1000, // 30 minutes
     });
-    (0, logger_1.log)('debug', 'cookiePool.sessionSticky', { sessionId, accountId });
+    (0, logger_1.log)("debug", "cookiePool.sessionSticky", { sessionId, accountId });
 }
 function clearSessionAccount(sessionId) {
     sessionAccountMap.delete(sessionId);
-    (0, logger_1.log)('debug', 'cookiePool.sessionCleared', { sessionId });
+    (0, logger_1.log)("debug", "cookiePool.sessionCleared", { sessionId });
 }
 // Modified selectAccountForRequest to support sessions (Phase 2.1)
 async function selectAccountForRequest(sessionId) {
@@ -245,8 +262,14 @@ async function selectAccountForRequest(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 });
+            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 };
             }
@@ -272,8 +295,12 @@ async function selectAccountForRequest(sessionId) {
             continue;
         // Select this account
         poolState.rrIndex = (idx + 1) % n;
-        (0, logger_1.log)('debug', 'cookiePool.select', { accountId: entry.accountId, rrIndex: poolState.rrIndex, sessionId: sessionId || 'none' });
-        (0, metrics_1.incrementMetric)('accountSelections');
+        (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) {
@@ -281,7 +308,7 @@ async function selectAccountForRequest(sessionId) {
         }
         return { accountId: entry.accountId, cookies: entry.cookies };
     }
-    throw new errors_1.LinkedInClientError('No valid LinkedIn accounts', 'NO_VALID_ACCOUNTS', 503);
+    throw new errors_1.LinkedInClientError("No valid LinkedIn accounts", "NO_VALID_ACCOUNTS", 503);
 }
 function getAccountsSummary() {
     const now = nowMs();
@@ -314,9 +341,14 @@ function reportAccountFailure(accountId, isAuthError) {
     if (isAuthError || entry.failures >= settings.maxFailures) {
         entry.cooldownUntil = nowMs() + settings.cooldownMs;
     }
-    (0, logger_1.log)('warn', 'cookiePool.failure', { accountId, failures: entry.failures, isAuthError, cooldownUntil: entry.cooldownUntil });
+    (0, logger_1.log)("warn", "cookiePool.failure", {
+        accountId,
+        failures: entry.failures,
+        isAuthError,
+        cooldownUntil: entry.cooldownUntil,
+    });
     if (isAuthError)
-        (0, metrics_1.incrementMetric)('authErrors');
+        (0, metrics_1.incrementMetric)("authErrors");
 }
 function reportAccountSuccess(accountId) {
     const entry = poolState.accounts.get(accountId);
@@ -324,16 +356,16 @@ function reportAccountSuccess(accountId) {
         return;
     entry.failures = 0;
     entry.cooldownUntil = 0;
-    (0, logger_1.log)('debug', 'cookiePool.success', { accountId });
+    (0, logger_1.log)("debug", "cookiePool.success", { accountId });
 }
 function buildCookieHeader(cookies) {
-    return cookies.map(c => `${c.name}=${c.value}`).join('; ');
+    return cookies.map((c) => `${c.name}=${c.value}`).join("; ");
 }
 function extractCsrfToken(cookies) {
-    const jsession = cookies.find(c => c.name.toUpperCase() === 'JSESSIONID');
+    const jsession = cookies.find((c) => c.name.toUpperCase() === "JSESSIONID");
     if (!jsession || !jsession.value)
-        throw new Error('Missing CSRF token');
-    return jsession.value.replace(/^\"|\"$/g, '');
+        throw new Error("Missing CSRF token");
+    return jsession.value.replace(/^\"|\"$/g, "");
 }
 function getSettings() {
     try {
@@ -372,7 +404,7 @@ function adminResetAccount(accountId) {
  */
 function _testGetAllAccountIds() {
     if (!poolState.initialized) {
-        throw new Error('TEST: Cookie pool not initialized. Call initializeLinkedInClient() first.');
+        throw new Error("TEST: Cookie pool not initialized. Call initializeLinkedInClient() first.");
     }
     return Array.from(poolState.accounts.keys());
 }
@@ -383,7 +415,7 @@ function _testGetAllAccountIds() {
  */
 function _testGetAccountCookies(accountId) {
     if (!poolState.initialized) {
-        throw new Error('TEST: Cookie pool not initialized. Call initializeLinkedInClient() first.');
+        throw new Error("TEST: Cookie pool not initialized. Call initializeLinkedInClient() first.");
     }
     return poolState.accounts.get(accountId)?.cookies;
 }
@@ -394,7 +426,7 @@ function _testGetAccountCookies(accountId) {
  */
 function _testGetAccountEntry(accountId) {
     if (!poolState.initialized) {
-        throw new Error('TEST: Cookie pool not initialized. Call initializeLinkedInClient() first.');
+        throw new Error("TEST: Cookie pool not initialized. Call initializeLinkedInClient() first.");
     }
     return poolState.accounts.get(accountId);
 }

package/dist/cosiall-client.d.ts

@@ -1,2 +1,21 @@
-import type { AccountCookies } from './types';
+import type { AccountCookies } from "./types";
+/**
+ * Fetches LinkedIn cookies for all available accounts from the Cosiall API.
+ * These cookies are used for authenticating requests to LinkedIn's API.
+ *
+ * @returns Array of AccountCookies, each containing accountId, cookies array, and optional expiresAt
+ * @throws LinkedInClientError with code REQUEST_FAILED if Cosiall API returns non-OK status
+ * @throws LinkedInClientError with code REQUEST_FAILED if response format is invalid
+ *
+ * @remarks
+ * - Reports failures to Sentry if configured
+ * - Validates each account has required cookie structure
+ * - Filters out malformed account entries
+ *
+ * @example
+ * ```typescript
+ * const accounts = await fetchCookiesFromCosiall();
+ * console.log(`Loaded ${accounts.length} LinkedIn accounts`);
+ * ```
+ */
 export declare function fetchCookiesFromCosiall(): Promise<AccountCookies[]>;

package/dist/cosiall-client.js

@@ -38,69 +38,92 @@ const config_1 = require("./config");
 const errors_1 = require("./utils/errors");
 const logger_1 = require("./utils/logger");
 const metrics_1 = require("./utils/metrics");
+/**
+ * Fetches LinkedIn cookies for all available accounts from the Cosiall API.
+ * These cookies are used for authenticating requests to LinkedIn's API.
+ *
+ * @returns Array of AccountCookies, each containing accountId, cookies array, and optional expiresAt
+ * @throws LinkedInClientError with code REQUEST_FAILED if Cosiall API returns non-OK status
+ * @throws LinkedInClientError with code REQUEST_FAILED if response format is invalid
+ *
+ * @remarks
+ * - Reports failures to Sentry if configured
+ * - Validates each account has required cookie structure
+ * - Filters out malformed account entries
+ *
+ * @example
+ * ```typescript
+ * const accounts = await fetchCookiesFromCosiall();
+ * console.log(`Loaded ${accounts.length} LinkedIn accounts`);
+ * ```
+ */
 async function fetchCookiesFromCosiall() {
     const { cosiallApiUrl, cosiallApiKey } = (0, config_1.getConfig)();
-    const base = cosiallApiUrl.replace(/\/+$/, '');
+    const base = cosiallApiUrl.replace(/\/+$/, "");
     const url = `${base}/api/flexiq/linkedin-cookies/all`;
-    (0, logger_1.log)('info', 'cosiall.fetch.start', { url });
-    (0, metrics_1.incrementMetric)('cosiallFetches');
+    (0, logger_1.log)("info", "cosiall.fetch.start", { url });
+    (0, metrics_1.incrementMetric)("cosiallFetches");
     const response = await fetch(url, {
-        method: 'GET',
+        method: "GET",
         headers: {
-            'X-API-Key': cosiallApiKey,
-            'Accept': 'application/json',
+            "X-API-Key": cosiallApiKey,
+            Accept: "application/json",
         },
     });
     if (!response.ok) {
-        (0, logger_1.log)('warn', 'cosiall.fetch.error', { status: response.status });
-        (0, metrics_1.incrementMetric)('cosiallFailures');
+        (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', {
+            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' },
+                tags: { component: "cosiall-client", severity: "critical" },
             });
         }
         catch { }
-        throw new errors_1.LinkedInClientError('Cosiall fetch failed', 'REQUEST_FAILED', response.status);
+        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 });
+        (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',
+            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' },
+                tags: { component: "cosiall-client", severity: "critical" },
             });
         }
         catch { }
-        throw new errors_1.LinkedInClientError('Invalid Cosiall response format', 'REQUEST_FAILED', 500);
+        throw new errors_1.LinkedInClientError("Invalid Cosiall response format", "REQUEST_FAILED", 500);
     }
-    (0, logger_1.log)('info', 'cosiall.fetch.success', { count: data.length });
-    (0, metrics_1.incrementMetric)('cosiallSuccess');
+    (0, logger_1.log)("info", "cosiall.fetch.success", { count: data.length });
+    (0, metrics_1.incrementMetric)("cosiallSuccess");
     function isCookie(obj) {
-        return !!obj && typeof obj === 'object' && 'name' in obj && 'value' in obj;
+        return !!obj && typeof obj === "object" && "name" in obj && "value" in obj;
     }
     function isItem(obj) {
-        if (!obj || typeof obj !== 'object')
+        if (!obj || typeof obj !== "object")
             return false;
         const rec = obj;
-        if (typeof rec.accountId !== 'string')
+        if (typeof rec.accountId !== "string")
             return false;
         if (!Array.isArray(rec.cookies))
             return false;
         if (!rec.cookies.every(isCookie))
             return false;
-        if (rec.expiresAt !== undefined && typeof rec.expiresAt !== 'number')
+        if (rec.expiresAt !== undefined && typeof rec.expiresAt !== "number")
             return false;
         return true;
     }
     return data
         .filter(isItem)
-        .map((item) => ({ accountId: item.accountId, cookies: item.cookies, expiresAt: item.expiresAt }));
+        .map((item) => ({
+        accountId: item.accountId,
+        cookies: item.cookies,
+        expiresAt: item.expiresAt,
+    }));
 }

package/dist/enrichment/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Email Enrichment Module
+ *
+ * Provides email enrichment capabilities with multiple provider support,
+ * waterfall orchestration, and configurable options.
+ *
+ * @example
+ * ```typescript
+ * import { createEnrichmentClient } from 'linkedin-secret-sauce';
+ *
+ * const enricher = createEnrichmentClient({
+ *   providers: {
+ *     hunter: { apiKey: process.env.HUNTER_API_KEY },
+ *     apollo: { apiKey: process.env.APOLLO_API_KEY },
+ *   },
+ *   options: {
+ *     maxCostPerEmail: 0.05,
+ *     confidenceThreshold: 50,
+ *   },
+ * });
+ *
+ * const result = await enricher.enrich({
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   company: 'Acme Corp',
+ * });
+ * ```
+ */
+import type { EnrichmentClientConfig, EnrichmentClient } from './types';
+/**
+ * Create an enrichment client with the given configuration
+ *
+ * @param config - Configuration for the enrichment client
+ * @returns An enrichment client with enrich and enrichBatch methods
+ */
+export declare function createEnrichmentClient(config: EnrichmentClientConfig): EnrichmentClient;
+export * from './types';
+export { isPersonalEmail, isBusinessEmail, isPersonalDomain, PERSONAL_DOMAINS, } from './utils/personal-domains';
+export { isDisposableEmail, isDisposableDomain, DISPOSABLE_DOMAINS, } from './utils/disposable-domains';
+export { isValidEmailSyntax, isRoleAccount, asciiFold, cleanNamePart, hostnameFromUrl, extractLinkedInUsername, } from './utils/validation';
+export { verifyEmailMx } from './verification/mx';
+export { createConstructProvider, createLddProvider, createSmartProspectProvider, createHunterProvider, createApolloProvider, createDropcontactProvider, } from './providers';
+export { enrichBusinessEmail, enrichBatch } from './orchestrator';