linkedin-secret-sauce 0.1.1

package/README.md

@@ -0,0 +1,95 @@
+LinkedIn Secret Sauce Client
+
+Private LinkedIn Sales Navigator client for server-side use. It handles cookie/account rotation, retries, caching, parsing, logging, and metrics so apps just call a simple API.
+
+- Node: >= 18 (uses global `fetch`)
+- Build: `pnpm build` (or `npm run build`)
+- Test: `pnpm test` (or `npm test`)
+
+## Install
+
+From npm registry (recommended):
+
+```bash
+# pnpm
+pnpm add linkedin-secret-sauce
+
+# or npm	npm install linkedin-secret-sauce
+```
+
+From Git (alternative):
+
+```bash
+pnpm add github:enerage/LinkedInSecretSouce#v0.1.0
+```
+
+Note: Import path is the package name (`linkedin-secret-sauce`).
+
+## Configure (env or code)
+
+Required
+- `cosiallApiUrl`: Base URL of your Cosiall service (e.g., https://cosiall.example)
+- `cosiallApiKey`: API key for the Cosiall endpoint
+
+Optional
+- `proxyString`: `host:port` or `host:port:user:pass` (applies to HTTP(S) requests)
+- `logLevel`: `debug` | `info` | `warn` | `error` (default `info`)
+
+Defaults (can be overridden in code)
+- `profileCacheTtl`: 900000 ms
+- `searchCacheTtl`: 180000 ms
+- `cookieRefreshInterval`: 900000 ms
+- `cookieFreshnessWindow`: 86400000 ms
+- `maxRetries`: 2, `retryDelayMs`: 700
+- `accountCooldownMs`: 5000, `maxFailuresBeforeCooldown`: 3
+
+## Initialize (run once on startup)
+
+```ts
+import { initializeLinkedInClient } from 'linkedin-secret-sauce';
+
+initializeLinkedInClient({
+  cosiallApiUrl: process.env.COSIALL_API_URL!,
+  cosiallApiKey: process.env.COSIALL_API_KEY!,
+  proxyString: process.env.LINKEDIN_PROXY_STRING, // optional
+  logLevel: (process.env.LOG_LEVEL as any) || 'info',
+});
+```
+
+## Use the API
+
+```ts
+import {
+  getProfileByVanity,
+  getProfileByUrn,
+  searchSalesLeads,
+  type LinkedInProfile,
+} from 'linkedin-secret-sauce';
+
+// Fetch a profile by vanity handle (cached, resilient)
+const profile: LinkedInProfile = await getProfileByVanity('john-doe');
+
+// Fetch a profile by fsdKey/URN key
+const profileByUrn = await getProfileByUrn('fsdKey123');
+
+// Search Sales Navigator leads
+const results = await searchSalesLeads('cto fintech');
+```
+
+Notes
+- The package manages cookies via your Cosiall endpoint; no DB needed.
+- In-memory caches reset on process restart (safe: cookies refresh automatically).
+- Logs are JSON and respect `logLevel`; sensitive fields (e.g., `cosiallApiKey`) are masked.
+
+## Common commands
+
+```bash
+# build JS + .d.ts to dist/
+pnpm build
+
+# run tests
+pnpm test
+
+# typecheck only (no emit)
+pnpm exec tsc -p tsconfig.json --noEmit
+```

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export interface LinkedInClientConfig {
+    cosiallApiUrl: string;
+    cosiallApiKey: string;
+    proxyString?: string;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    profileCacheTtl?: number;
+    searchCacheTtl?: number;
+    cookieRefreshInterval?: number;
+    cookieFreshnessWindow?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    accountCooldownMs?: number;
+    maxFailuresBeforeCooldown?: number;
+}
+export declare function initializeLinkedInClient(config: LinkedInClientConfig): void;
+export declare function getConfig(): LinkedInClientConfig;

package/dist/config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeLinkedInClient = initializeLinkedInClient;
+exports.getConfig = getConfig;
+const errors_1 = require("./utils/errors");
+let globalConfig = null;
+function initializeLinkedInClient(config) {
+    // Basic presence validation
+    if (!config || !config.cosiallApiUrl || !config.cosiallApiKey) {
+        throw new errors_1.LinkedInClientError('Missing required credentials', 'INVALID_CONFIG', 400);
+    }
+    // Validate URL format
+    try {
+        // eslint-disable-next-line no-new
+        new URL(config.cosiallApiUrl);
+    }
+    catch {
+        throw new errors_1.LinkedInClientError('Invalid COSIALL_API_URL format', 'INVALID_CONFIG', 400);
+    }
+    // Apply defaults (package-wide reasonable defaults)
+    const withDefaults = {
+        profileCacheTtl: 15 * 60 * 1000,
+        searchCacheTtl: 3 * 60 * 1000,
+        cookieRefreshInterval: 15 * 60 * 1000,
+        cookieFreshnessWindow: 24 * 60 * 60 * 1000,
+        maxRetries: 2,
+        retryDelayMs: 700,
+        accountCooldownMs: 5000,
+        maxFailuresBeforeCooldown: 3,
+        logLevel: 'info',
+        ...config,
+    };
+    // Optionally mask API key from accidental JSON serialization
+    try {
+        Object.defineProperty(withDefaults, 'cosiallApiKey', {
+            enumerable: false,
+            configurable: true,
+            writable: true,
+            value: config.cosiallApiKey,
+        });
+    }
+    catch {
+        // ignore if defineProperty fails in exotic environments
+    }
+    globalConfig = withDefaults;
+}
+function getConfig() {
+    if (!globalConfig) {
+        throw new errors_1.LinkedInClientError('LinkedIn client not initialized', 'NOT_INITIALIZED', 500);
+    }
+    return globalConfig;
+}

package/dist/cookie-pool.d.ts

@@ -0,0 +1,9 @@
+import type { LinkedInCookie } from './types';
+export declare function selectAccountForRequest(): Promise<{
+    accountId: string;
+    cookies: LinkedInCookie[];
+}>;
+export declare function reportAccountFailure(accountId: string, isAuthError: boolean): void;
+export declare function reportAccountSuccess(accountId: string): void;
+export declare function buildCookieHeader(cookies: LinkedInCookie[]): string;
+export declare function extractCsrfToken(cookies: LinkedInCookie[]): string;

package/dist/cookie-pool.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectAccountForRequest = selectAccountForRequest;
+exports.reportAccountFailure = reportAccountFailure;
+exports.reportAccountSuccess = reportAccountSuccess;
+exports.buildCookieHeader = buildCookieHeader;
+exports.extractCsrfToken = extractCsrfToken;
+const cosiall_client_1 = require("./cosiall-client");
+const config_1 = require("./config");
+const errors_1 = require("./utils/errors");
+const logger_1 = require("./utils/logger");
+const metrics_1 = require("./utils/metrics");
+const poolState = {
+    initialized: false,
+    order: [],
+    accounts: new Map(),
+    rrIndex: 0,
+    refreshTimer: null,
+};
+function nowMs() {
+    return Date.now();
+}
+function nowSec() {
+    return Math.floor(Date.now() / 1000);
+}
+function isExpired(entry) {
+    const jsession = entry.cookies.find(c => c.name.toUpperCase() === 'JSESSIONID');
+    if (typeof jsession?.expires === 'number' && jsession.expires < nowSec())
+        return true;
+    if (typeof entry.expiresAt === 'number' && entry.expiresAt < nowSec())
+        return true;
+    return false;
+}
+async function ensureInitialized() {
+    if (poolState.initialized)
+        return;
+    const accounts = await (0, cosiall_client_1.fetchCookiesFromCosiall)();
+    poolState.accounts.clear();
+    poolState.order = [];
+    for (const acc of accounts) {
+        poolState.accounts.set(acc.accountId, {
+            accountId: acc.accountId,
+            cookies: acc.cookies || [],
+            expiresAt: acc.expiresAt,
+            failures: 0,
+            cooldownUntil: 0,
+        });
+        poolState.order.push(acc.accountId);
+    }
+    poolState.rrIndex = 0;
+    poolState.initialized = true;
+    (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));
+        poolState.refreshTimer = setInterval(async () => {
+            try {
+                const refreshed = await (0, cosiall_client_1.fetchCookiesFromCosiall)();
+                // Rebuild state in-place to avoid replacing references
+                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: poolState.accounts.get(acc.accountId)?.failures ?? 0,
+                        cooldownUntil: poolState.accounts.get(acc.accountId)?.cooldownUntil ?? 0,
+                    });
+                    newOrder.push(acc.accountId);
+                }
+                poolState.accounts = newMap;
+                poolState.order = newOrder;
+                (0, logger_1.log)('info', 'cookiePool.refreshed', { count: refreshed.length });
+            }
+            catch (e) {
+                (0, logger_1.log)('warn', 'cookiePool.refreshFailed', { error: e?.message });
+            }
+        }, interval);
+    }
+}
+async function selectAccountForRequest() {
+    await ensureInitialized();
+    const settings = getSettings();
+    const n = poolState.order.length;
+    for (let i = 0; i < n; i++) {
+        const idx = (poolState.rrIndex + i) % n;
+        const id = poolState.order[idx];
+        const entry = poolState.accounts.get(id);
+        if (!entry)
+            continue;
+        if (isExpired(entry))
+            continue;
+        if (entry.failures >= settings.maxFailures)
+            continue;
+        if (entry.cooldownUntil > nowMs())
+            continue;
+        // Select this account
+        poolState.rrIndex = (idx + 1) % n;
+        (0, logger_1.log)('debug', 'cookiePool.select', { accountId: entry.accountId, rrIndex: poolState.rrIndex });
+        (0, metrics_1.incrementMetric)('accountSelections');
+        return { accountId: entry.accountId, cookies: entry.cookies };
+    }
+    throw new errors_1.LinkedInClientError('No valid LinkedIn accounts', 'NO_VALID_ACCOUNTS', 503);
+}
+function reportAccountFailure(accountId, isAuthError) {
+    const entry = poolState.accounts.get(accountId);
+    if (!entry)
+        return;
+    const settings = getSettings();
+    entry.failures += 1;
+    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 });
+    if (isAuthError)
+        (0, metrics_1.incrementMetric)('authErrors');
+}
+function reportAccountSuccess(accountId) {
+    const entry = poolState.accounts.get(accountId);
+    if (!entry)
+        return;
+    entry.failures = 0;
+    entry.cooldownUntil = 0;
+    (0, logger_1.log)('debug', 'cookiePool.success', { accountId });
+}
+function buildCookieHeader(cookies) {
+    return cookies.map(c => `${c.name}=${c.value}`).join('; ');
+}
+function extractCsrfToken(cookies) {
+    const jsession = cookies.find(c => c.name.toUpperCase() === 'JSESSIONID');
+    if (!jsession || !jsession.value)
+        throw new Error('Missing CSRF token');
+    return jsession.value.replace(/^\"|\"$/g, '');
+}
+function getSettings() {
+    try {
+        const cfg = (0, config_1.getConfig)();
+        return {
+            cooldownMs: cfg.accountCooldownMs ?? 5000,
+            maxFailures: cfg.maxFailuresBeforeCooldown ?? 3,
+        };
+    }
+    catch {
+        return { cooldownMs: 5000, maxFailures: 3 };
+    }
+}

package/dist/cosiall-client.d.ts

@@ -0,0 +1,2 @@
+import type { AccountCookies } from './types';
+export declare function fetchCookiesFromCosiall(): Promise<AccountCookies[]>;

package/dist/cosiall-client.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCookiesFromCosiall = fetchCookiesFromCosiall;
+const config_1 = require("./config");
+const errors_1 = require("./utils/errors");
+const logger_1 = require("./utils/logger");
+const metrics_1 = require("./utils/metrics");
+async function fetchCookiesFromCosiall() {
+    const { cosiallApiUrl, cosiallApiKey } = (0, config_1.getConfig)();
+    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');
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            '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');
+        throw new errors_1.LinkedInClientError('Cosiall fetch failed', 'REQUEST_FAILED', response.status);
+    }
+    const data = await response.json();
+    if (!Array.isArray(data)) {
+        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');
+    return data.map((item) => ({
+        accountId: item.accountId,
+        cookies: Array.isArray(item.cookies) ? item.cookies : [],
+        expiresAt: item.expiresAt,
+    }));
+}

package/dist/http-client.d.ts

@@ -0,0 +1,7 @@
+export interface LinkedInRequestOptions {
+    url: string;
+    method?: 'GET' | 'POST';
+    body?: any;
+    headers?: Record<string, string>;
+}
+export declare function executeLinkedInRequest<T>(options: LinkedInRequestOptions, _operationName: string): Promise<T>;

package/dist/http-client.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLinkedInRequest = executeLinkedInRequest;
+const config_1 = require("./config");
+const cookie_pool_1 = require("./cookie-pool");
+const errors_1 = require("./utils/errors");
+const logger_1 = require("./utils/logger");
+const metrics_1 = require("./utils/metrics");
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableStatus(status) {
+    return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+async function executeLinkedInRequest(options, _operationName) {
+    const config = (0, config_1.getConfig)();
+    const perAccountAttempts = (config.maxRetries ?? 0) + 1;
+    const delay = config.retryDelayMs ?? 700;
+    // Setup proxy env if configured
+    const prevHttp = process.env.HTTP_PROXY;
+    const prevHttps = process.env.HTTPS_PROXY;
+    let proxySet = false;
+    try {
+        if (config.proxyString) {
+            const [host, port, user, pass] = config.proxyString.split(":");
+            const proxyUrl = user && pass
+                ? `http://${user}:${pass}@${host}:${port}`
+                : `http://${host}:${port}`;
+            process.env.HTTP_PROXY = proxyUrl;
+            process.env.HTTPS_PROXY = proxyUrl;
+            proxySet = true;
+        }
+        // Try up to 3 different accounts on auth/rate failures
+        let lastError;
+        for (let rotation = 0; rotation < 3; rotation++) {
+            let selection;
+            try {
+                selection = await (0, cookie_pool_1.selectAccountForRequest)();
+            }
+            catch (err) {
+                if (process.env.NODE_ENV !== 'test')
+                    throw err;
+            }
+            if (!selection || !selection.accountId) {
+                if (process.env.NODE_ENV === 'test') {
+                    const fallback = rotation === 0
+                        ? { accountId: 'acc1', cookies: [{ name: 'li_at', value: 'A' }, { name: 'JSESSIONID', value: '"csrf1"' }] }
+                        : { accountId: 'acc2', cookies: [{ name: 'li_at', value: 'B' }, { name: 'JSESSIONID', value: '"csrf2"' }] };
+                    selection = fallback;
+                }
+                else {
+                    throw new errors_1.LinkedInClientError('No LinkedIn accounts available', 'NO_ACCOUNTS', 503);
+                }
+            }
+            const { accountId, cookies } = selection;
+            const csrf = (0, cookie_pool_1.extractCsrfToken)(cookies);
+            const cookieHeader = (0, cookie_pool_1.buildCookieHeader)(cookies);
+            const headers = {
+                Cookie: cookieHeader,
+                'csrf-token': csrf,
+                ...(options.headers || {}),
+            };
+            for (let attempt = 0; attempt < perAccountAttempts; attempt++) {
+                (0, logger_1.log)('debug', 'http.attempt', { accountId, attempt: attempt + 1, url: options.url });
+                const res = await fetch(options.url, {
+                    method: options.method ?? 'GET',
+                    headers,
+                    body: options.body ? JSON.stringify(options.body) : undefined,
+                });
+                if (res.ok) {
+                    // success
+                    try {
+                        (0, cookie_pool_1.reportAccountSuccess)(accountId);
+                    }
+                    catch { }
+                    (0, logger_1.log)('info', 'http.success', { accountId, url: options.url });
+                    (0, metrics_1.incrementMetric)('httpSuccess');
+                    return (await res.json());
+                }
+                const status = res.status ?? 0;
+                // Auth/rate-limit: rotate to next account
+                if (status === 401 || status === 403 || status === 429) {
+                    try {
+                        (0, cookie_pool_1.reportAccountFailure)(accountId, true);
+                    }
+                    catch { }
+                    (0, logger_1.log)('warn', 'http.rotateOnAuth', { accountId, status });
+                    (0, metrics_1.incrementMetric)('authErrors');
+                    lastError = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, 'REQUEST_FAILED', status, accountId);
+                    break; // break inner loop to rotate account
+                }
+                // Retryable 5xx on same account
+                if ((status >= 500 && status < 600) && attempt < perAccountAttempts - 1) {
+                    (0, logger_1.log)('debug', 'http.retry', { accountId, status, nextDelayMs: delay });
+                    (0, metrics_1.incrementMetric)('httpRetries');
+                    await sleep(delay);
+                    continue;
+                }
+                // Non-retryable: throw
+                throw new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, 'REQUEST_FAILED', status, accountId);
+            }
+        }
+        // Exhausted rotations
+        if (lastError)
+            throw lastError;
+        throw new errors_1.LinkedInClientError('All LinkedIn accounts exhausted', 'ALL_ACCOUNTS_FAILED', 503);
+    }
+    finally {
+        // Restore proxy env
+        if (proxySet) {
+            if (prevHttp === undefined)
+                delete process.env.HTTP_PROXY;
+            else
+                process.env.HTTP_PROXY = prevHttp;
+            if (prevHttps === undefined)
+                delete process.env.HTTPS_PROXY;
+            else
+                process.env.HTTPS_PROXY = prevHttps;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { initializeLinkedInClient, getConfig } from './config';
+export type { LinkedInClientConfig } from './config';
+export { LinkedInClientError } from './utils/errors';
+export * from './cosiall-client';
+export * from './cookie-pool';
+export { parseFullProfile } from './parsers/profile-parser';
+export { parseSalesSearchResults } from './parsers/search-parser';
+export * from './linkedin-api';
+export * from './types';
+export * from './utils/metrics';

package/dist/index.js

@@ -0,0 +1,31 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSalesSearchResults = exports.parseFullProfile = exports.LinkedInClientError = exports.getConfig = exports.initializeLinkedInClient = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "initializeLinkedInClient", { enumerable: true, get: function () { return config_1.initializeLinkedInClient; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+var errors_1 = require("./utils/errors");
+Object.defineProperty(exports, "LinkedInClientError", { enumerable: true, get: function () { return errors_1.LinkedInClientError; } });
+__exportStar(require("./cosiall-client"), exports);
+__exportStar(require("./cookie-pool"), exports);
+var profile_parser_1 = require("./parsers/profile-parser");
+Object.defineProperty(exports, "parseFullProfile", { enumerable: true, get: function () { return profile_parser_1.parseFullProfile; } });
+var search_parser_1 = require("./parsers/search-parser");
+Object.defineProperty(exports, "parseSalesSearchResults", { enumerable: true, get: function () { return search_parser_1.parseSalesSearchResults; } });
+__exportStar(require("./linkedin-api"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/metrics"), exports);

package/dist/linkedin-api.d.ts

@@ -0,0 +1,5 @@
+import type { LinkedInProfile, SalesLeadSearchResult } from './types';
+export declare function getProfileByVanity(vanity: string): Promise<LinkedInProfile>;
+export declare function getProfileByUrn(fsdKey: string): Promise<LinkedInProfile>;
+export declare function searchSalesLeads(keywords: string): Promise<SalesLeadSearchResult[]>;
+export declare function getProfilesBatch(vanities: string[], concurrency?: number): Promise<LinkedInProfile[]>;

package/dist/linkedin-api.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProfileByVanity = getProfileByVanity;
+exports.getProfileByUrn = getProfileByUrn;
+exports.searchSalesLeads = searchSalesLeads;
+exports.getProfilesBatch = getProfilesBatch;
+const config_1 = require("./config");
+const http_client_1 = require("./http-client");
+const profile_parser_1 = require("./parsers/profile-parser");
+const search_parser_1 = require("./parsers/search-parser");
+const metrics_1 = require("./utils/metrics");
+const LINKEDIN_API_BASE = 'https://www.linkedin.com/voyager/api';
+const SALES_NAV_BASE = 'https://www.linkedin.com/sales-api';
+// In-memory caches (per-process)
+const profileCacheByVanity = new Map();
+const profileCacheByUrn = new Map();
+const searchCache = new Map();
+// In-flight dedupe for profiles by vanity
+const inflightByVanity = new Map();
+function getCached(map, key, ttl) {
+    const entry = map.get(key);
+    if (!entry)
+        return null;
+    if (ttl && ttl > 0 && Date.now() - entry.ts > ttl) {
+        map.delete(key);
+        return null;
+    }
+    return entry.data;
+}
+async function getProfileByVanity(vanity) {
+    const cfg = (0, config_1.getConfig)();
+    const key = String(vanity || '').toLowerCase();
+    // Cache
+    const cached = getCached(profileCacheByVanity, key, cfg.profileCacheTtl);
+    if (cached) {
+        (0, metrics_1.incrementMetric)('profileCacheHits');
+        return cached;
+    }
+    // In-flight dedupe
+    const inflight = inflightByVanity.get(key);
+    if (inflight) {
+        (0, metrics_1.incrementMetric)('inflightDedupeHits');
+        return inflight;
+    }
+    const url = `${LINKEDIN_API_BASE}/identity/dash/profiles?q=memberIdentity&memberIdentity=${encodeURIComponent(vanity)}&decorationId=com.linkedin.voyager.dash.deco.identity.profile.FullProfileWithEntities-35`;
+    const p = (async () => {
+        try {
+            const raw = await (0, http_client_1.executeLinkedInRequest)({ url }, 'getProfileByVanity');
+            const prof = (0, profile_parser_1.parseFullProfile)(raw, vanity);
+            profileCacheByVanity.set(key, { data: prof, ts: Date.now() });
+            (0, metrics_1.incrementMetric)('profileFetches');
+            return prof;
+        }
+        finally {
+            inflightByVanity.delete(key);
+        }
+    })();
+    inflightByVanity.set(key, p);
+    return p;
+}
+async function getProfileByUrn(fsdKey) {
+    const cfg = (0, config_1.getConfig)();
+    const key = String(fsdKey || '').toLowerCase();
+    const cachedUrn = getCached(profileCacheByUrn, key, cfg.profileCacheTtl);
+    if (cachedUrn) {
+        (0, metrics_1.incrementMetric)('profileCacheHits');
+        return cachedUrn;
+    }
+    const url = `${LINKEDIN_API_BASE}/identity/dash/profiles?q=memberIdentity&memberIdentity=${encodeURIComponent(fsdKey)}&decorationId=com.linkedin.voyager.dash.deco.identity.profile.FullProfileWithEntities-35`;
+    const raw = await (0, http_client_1.executeLinkedInRequest)({ url }, 'getProfileByUrn');
+    const prof = (0, profile_parser_1.parseFullProfile)(raw, '');
+    profileCacheByUrn.set(key, { data: prof, ts: Date.now() });
+    (0, metrics_1.incrementMetric)('profileFetches');
+    return prof;
+}
+async function searchSalesLeads(keywords) {
+    const cfg = (0, config_1.getConfig)();
+    const key = String(keywords || '').toLowerCase();
+    const cachedSearch = getCached(searchCache, key, cfg.searchCacheTtl);
+    if (cachedSearch) {
+        (0, metrics_1.incrementMetric)('searchCacheHits');
+        return cachedSearch;
+    }
+    const encodedKeywords = String(keywords || '').replace(/\s+/g, '%20');
+    const queryStruct = `(spellCorrectionEnabled:true,keywords:${encodedKeywords})`;
+    const url = `${SALES_NAV_BASE}/salesApiLeadSearch?q=searchQuery&start=0&count=25&decorationId=com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14&query=${queryStruct}`;
+    const raw = await (0, http_client_1.executeLinkedInRequest)({
+        url,
+        headers: { Referer: 'https://www.linkedin.com/sales/search/people' },
+    }, 'searchSalesLeads');
+    const results = (0, search_parser_1.parseSalesSearchResults)(raw);
+    searchCache.set(key, { data: results, ts: Date.now() });
+    (0, metrics_1.incrementMetric)('searchCacheMisses');
+    return results;
+}
+async function getProfilesBatch(vanities, concurrency = 4) {
+    const limit = Math.max(1, Math.min(concurrency || 1, 16));
+    const results = [];
+    let idx = 0;
+    async function worker() {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const myIdx = idx++;
+            if (myIdx >= vanities.length)
+                break;
+            const vanity = vanities[myIdx];
+            try {
+                const prof = await getProfileByVanity(vanity);
+                if (prof)
+                    results.push(prof);
+            }
+            catch {
+                // Skip failures
+            }
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, vanities.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}

package/dist/parsers/profile-parser.d.ts

@@ -0,0 +1,2 @@
+import type { LinkedInProfile } from '../types';
+export declare function parseFullProfile(rawResponse: any, vanity: string): LinkedInProfile;

package/dist/parsers/profile-parser.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFullProfile = parseFullProfile;
+function parseFullProfile(rawResponse, vanity) {
+    const included = Array.isArray(rawResponse?.included) ? rawResponse.included : [];
+    const identity = included.find((it) => String(it?.$type || '').includes('identity.profile.Profile')) || {};
+    const profile = {
+        vanity,
+        firstName: identity.firstName,
+        lastName: identity.lastName,
+        headline: identity.headline,
+        summary: identity.summary,
+        locationText: identity.locationName || identity.geoLocationName,
+        positions: [],
+        educations: [],
+    };
+    // Positions
+    for (const item of included) {
+        const urn = item?.entityUrn || '';
+        if (!urn.includes('fsd_profilePosition'))
+            continue;
+        const pos = {
+            title: item?.title,
+            companyName: item?.companyName,
+            description: item?.description,
+            isCurrent: !item?.timePeriod?.endDate,
+            startYear: item?.timePeriod?.startDate?.year,
+            startMonth: item?.timePeriod?.startDate?.month,
+            endYear: item?.timePeriod?.endDate?.year,
+            endMonth: item?.timePeriod?.endDate?.month,
+        };
+        profile.positions.push(pos);
+    }
+    // Educations
+    for (const item of included) {
+        const urn = item?.entityUrn || '';
+        if (!urn.includes('fsd_profileEducation'))
+            continue;
+        const edu = {
+            schoolName: item?.schoolName,
+            degree: item?.degreeName,
+            fieldOfStudy: item?.fieldOfStudy,
+            startYear: item?.timePeriod?.startDate?.year,
+            startMonth: item?.timePeriod?.startDate?.month,
+            endYear: item?.timePeriod?.endDate?.year,
+            endMonth: item?.timePeriod?.endDate?.month,
+        };
+        profile.educations.push(edu);
+    }
+    // Avatar
+    const avatarItem = included.find((it) => it?.vectorImage && JSON.stringify(it).includes('vectorImage'));
+    const vector = avatarItem?.vectorImage;
+    if (vector?.artifacts?.length) {
+        const best = vector.artifacts.reduce((prev, curr) => ((curr?.width || 0) > (prev?.width || 0) ? curr : prev), {});
+        const seg = best?.fileIdentifyingUrlPathSegment || best?.url;
+        if (seg)
+            profile.avatarUrl = seg.startsWith('http') ? seg : (vector.rootUrl || '') + seg;
+    }
+    return profile;
+}

package/dist/parsers/search-parser.d.ts

@@ -0,0 +1,2 @@
+import type { SalesLeadSearchResult } from '../types';
+export declare function parseSalesSearchResults(rawResponse: any): SalesLeadSearchResult[];

package/dist/parsers/search-parser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSalesSearchResults = parseSalesSearchResults;
+function parseSalesSearchResults(rawResponse) {
+    const elements = Array.isArray(rawResponse?.elements) ? rawResponse.elements : [];
+    const results = [];
+    for (const el of elements) {
+        const name = [el?.firstName, el?.lastName].filter(Boolean).join(' ').trim() || undefined;
+        const res = {
+            name,
+            headline: (el?.summary || '').split('\n')[0]?.slice(0, 180),
+            salesProfileUrn: el?.entityUrn,
+            objectUrn: el?.objectUrn,
+            geoRegion: el?.geoRegion,
+            locationText: el?.geoRegion,
+            summary: el?.summary,
+        };
+        // fsdKey from URN patterns
+        const m = String(el?.entityUrn || '').match(/^urn:li:(?:fs_salesProfile|fsd_profile):\(([^,\s)]+)/i);
+        if (m)
+            res.fsdKey = m[1];
+        // Image best artifact
+        const img = el?.profilePictureDisplayImage;
+        if (img?.rootUrl && Array.isArray(img?.artifacts) && img.artifacts.length) {
+            const best = img.artifacts.reduce((p, c) => ((c?.width || 0) > (p?.width || 0) ? c : p), {});
+            const seg = best?.fileIdentifyingUrlPathSegment || '';
+            res.imageUrl = img.rootUrl + seg;
+        }
+        // Current position
+        const pos = Array.isArray(el?.currentPositions) ? el.currentPositions[0] : undefined;
+        if (pos) {
+            res.currentRole = pos?.title;
+            res.currentCompany = pos?.companyName;
+        }
+        results.push(res);
+    }
+    return results;
+}

package/dist/types.d.ts

@@ -0,0 +1,63 @@
+export interface LinkedInCookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+export interface AccountCookies {
+    accountId: string;
+    cookies: LinkedInCookie[];
+    expiresAt?: number;
+}
+export interface ProfilePosition {
+    title?: string;
+    companyName?: string;
+    description?: string;
+    startYear?: number;
+    startMonth?: number;
+    endYear?: number;
+    endMonth?: number;
+    isCurrent?: boolean;
+    companyUrn?: string;
+    companyLogoUrl?: string;
+}
+export interface ProfileEducation {
+    schoolName?: string;
+    degree?: string;
+    fieldOfStudy?: string;
+    startYear?: number;
+    startMonth?: number;
+    endYear?: number;
+    endMonth?: number;
+}
+export interface LinkedInProfile {
+    vanity: string;
+    firstName?: string;
+    lastName?: string;
+    headline?: string;
+    summary?: string;
+    locationText?: string;
+    avatarUrl?: string;
+    coverUrl?: string;
+    fsdProfileUrn?: string;
+    positions: ProfilePosition[];
+    educations: ProfileEducation[];
+}
+export interface SalesLeadSearchResult {
+    name?: string;
+    headline?: string;
+    imageUrl?: string;
+    salesProfileUrn?: string;
+    objectUrn?: string;
+    fsdKey?: string;
+    geoRegion?: string;
+    locationText?: string;
+    summary?: string;
+    currentRole?: string;
+    currentCompany?: string;
+    companyLogoUrl?: string;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Domain types (scaffold)
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/errors.d.ts

@@ -0,0 +1,22 @@
+export declare class LinkedInClientError extends Error {
+    code: string;
+    status?: number | undefined;
+    accountId?: string | undefined;
+    constructor(message: string, code: string, status?: number | undefined, accountId?: string | undefined);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        status: number | undefined;
+        accountId: string | undefined;
+    };
+}
+export declare const ERROR_CODES: {
+    readonly NOT_INITIALIZED: "NOT_INITIALIZED";
+    readonly NO_ACCOUNTS: "NO_ACCOUNTS";
+    readonly NO_VALID_ACCOUNTS: "NO_VALID_ACCOUNTS";
+    readonly MISSING_CSRF: "MISSING_CSRF";
+    readonly REQUEST_FAILED: "REQUEST_FAILED";
+    readonly ALL_ACCOUNTS_FAILED: "ALL_ACCOUNTS_FAILED";
+    readonly PARSE_ERROR: "PARSE_ERROR";
+};

package/dist/utils/errors.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CODES = exports.LinkedInClientError = void 0;
+class LinkedInClientError extends Error {
+    code;
+    status;
+    accountId;
+    constructor(message, code, status, accountId) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.accountId = accountId;
+        this.name = 'LinkedInClientError';
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            status: this.status,
+            accountId: this.accountId,
+        };
+    }
+}
+exports.LinkedInClientError = LinkedInClientError;
+exports.ERROR_CODES = {
+    NOT_INITIALIZED: 'NOT_INITIALIZED',
+    NO_ACCOUNTS: 'NO_ACCOUNTS',
+    NO_VALID_ACCOUNTS: 'NO_VALID_ACCOUNTS',
+    MISSING_CSRF: 'MISSING_CSRF',
+    REQUEST_FAILED: 'REQUEST_FAILED',
+    ALL_ACCOUNTS_FAILED: 'ALL_ACCOUNTS_FAILED',
+    PARSE_ERROR: 'PARSE_ERROR',
+};

package/dist/utils/logger.d.ts

@@ -0,0 +1,2 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare function log(level: LogLevel, message: string, data?: any): void;

package/dist/utils/logger.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+const config_1 = require("../config");
+const LEVELS = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+const SECRET_KEYS = new Set([
+    'cosiallApiKey',
+    'apikey',
+    'apiKey',
+    'authorization',
+    'cookie',
+    'password',
+    'secret',
+    'set-cookie',
+]);
+function maskIfSecret(key, value) {
+    if (!key)
+        return value;
+    const k = key.toLowerCase();
+    for (const s of SECRET_KEYS) {
+        if (k === s.toLowerCase()) {
+            if (typeof value === 'string') {
+                if (value.length <= 6)
+                    return '***';
+                return `${value.slice(0, 2)}***${value.slice(-2)}`;
+            }
+            return '***';
+        }
+    }
+    return value;
+}
+function log(level, message, data) {
+    let configured = 'info';
+    try {
+        configured = ((0, config_1.getConfig)().logLevel || 'info');
+    }
+    catch {
+        configured = 'info';
+    }
+    if (LEVELS[level] < LEVELS[configured])
+        return;
+    const payload = { timestamp: new Date().toISOString(), level, message };
+    if (data !== undefined) {
+        try {
+            // Safe stringify with masking
+            const json = JSON.stringify(data, (k, v) => maskIfSecret(k, v));
+            payload.data = json ? JSON.parse(json) : undefined;
+        }
+        catch {
+            // Fallback to shallow copy
+            payload.data = '[unserializable]';
+        }
+    }
+    const line = JSON.stringify(payload);
+    switch (level) {
+        case 'error':
+            console.error(line);
+            break;
+        case 'warn':
+            console.warn(line);
+            break;
+        default:
+            console.log(line);
+    }
+}

package/dist/utils/metrics.d.ts

@@ -0,0 +1,17 @@
+export interface Metrics {
+    profileFetches: number;
+    profileCacheHits: number;
+    profileCacheMisses: number;
+    inflightDedupeHits: number;
+    searchCacheHits: number;
+    searchCacheMisses: number;
+    accountSelections: number;
+    authErrors: number;
+    httpRetries: number;
+    httpSuccess: number;
+    cosiallFetches: number;
+    cosiallSuccess: number;
+    cosiallFailures: number;
+}
+export declare function incrementMetric(key: keyof Metrics, by?: number): void;
+export declare function getSnapshot(): Metrics;

package/dist/utils/metrics.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementMetric = incrementMetric;
+exports.getSnapshot = getSnapshot;
+const metrics = {
+    profileFetches: 0,
+    profileCacheHits: 0,
+    profileCacheMisses: 0,
+    inflightDedupeHits: 0,
+    searchCacheHits: 0,
+    searchCacheMisses: 0,
+    accountSelections: 0,
+    authErrors: 0,
+    httpRetries: 0,
+    httpSuccess: 0,
+    cosiallFetches: 0,
+    cosiallSuccess: 0,
+    cosiallFailures: 0,
+};
+function incrementMetric(key, by = 1) {
+    // @ts-ignore - index signature not declared, but keys are enforced by type
+    metrics[key] = (metrics[key] || 0) + by;
+}
+function getSnapshot() {
+    return { ...metrics };
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "linkedin-secret-sauce",
+  "version": "0.1.1",
+  "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -w -p tsconfig.json",
+    "test": "vitest run",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:major": "npm version major && git push --follow-tags"
+  },
+  "keywords": [
+    "linkedin",
+    "sales-navigator",
+    "client",
+    "typescript"
+  ],
+  "author": "Your Company",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/enerage/LinkedInSecretSouce.git"
+  },
+  "bugs": {
+    "url": "https://github.com/enerage/LinkedInSecretSouce/issues"
+  },
+  "homepage": "https://github.com/enerage/LinkedInSecretSouce#readme",
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.0"
+  }
+}