linkedin-secret-sauce 0.1.1 → 0.2.0

package/dist/http-client.js

@@ -6,6 +6,8 @@ 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");
+const request_history_1 = require("./utils/request-history");
+const linkedin_config_1 = require("./utils/linkedin-config");
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -14,6 +16,7 @@ function isRetryableStatus(status) {
 }
 async function executeLinkedInRequest(options, _operationName) {
     const config = (0, config_1.getConfig)();
+    const op = _operationName || 'request';
     const perAccountAttempts = (config.maxRetries ?? 0) + 1;
     const delay = config.retryDelayMs ?? 700;
     // Setup proxy env if configured
@@ -22,13 +25,11 @@ async function executeLinkedInRequest(options, _operationName) {
     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}`;
+            const { url: proxyUrl, masked } = parseProxyString(config.proxyString);
             process.env.HTTP_PROXY = proxyUrl;
             process.env.HTTPS_PROXY = proxyUrl;
             proxySet = true;
+            (0, logger_1.log)('info', 'proxy.set', { host: masked });
         }
         // Try up to 3 different accounts on auth/rate failures
         let lastError;
@@ -55,18 +56,42 @@ async function executeLinkedInRequest(options, _operationName) {
             const { accountId, cookies } = selection;
             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
+            const isSales = /\/sales\//i.test(String(options.headers?.Referer || ''))
+                || /https:\/\/www\.linkedin\.com\/sales-api/i.test(options.url);
+            const baseHeaders = isSales
+                ? (0, linkedin_config_1.buildSalesHeaders)({ cookiesHeader: cookieHeader, csrf, referer: options.headers?.Referer })
+                : (0, linkedin_config_1.buildVoyagerHeaders)({ cookiesHeader: cookieHeader, csrf, referer: options.headers?.Referer });
             const headers = {
-                Cookie: cookieHeader,
-                'csrf-token': csrf,
+                ...baseHeaders,
                 ...(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,
-                });
+                const started = Date.now();
+                (0, logger_1.log)('debug', 'http.attempt', { accountId, attempt: attempt + 1, method: options.method ?? 'GET', url: options.url });
+                let res;
+                try {
+                    const init = {
+                        method: options.method ?? 'GET',
+                        headers,
+                    };
+                    if (options.body !== undefined) {
+                        init.body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
+                    }
+                    res = (await fetch(options.url, init));
+                }
+                catch (err) {
+                    const e = err;
+                    const code = e?.code || e?.cause?.code || 'FETCH_FAILED';
+                    (0, logger_1.log)('error', 'http.networkError', { accountId, url: options.url, code, message: String(e?.message || err) });
+                    (0, metrics_1.incrementMetric)('httpFailures');
+                    try {
+                        (0, request_history_1.recordRequest)({ operation: op, selector: options.url, status: 0, durationMs: Date.now() - started, accountId, errorMessage: String(e?.message || err) });
+                    }
+                    catch { }
+                    lastError = new errors_1.LinkedInClientError('LinkedIn fetch failed', 'REQUEST_FAILED', 0, accountId);
+                    break; // rotate to next account
+                }
                 if (res.ok) {
                     // success
                     try {
@@ -75,6 +100,16 @@ async function executeLinkedInRequest(options, _operationName) {
                     catch { }
                     (0, logger_1.log)('info', 'http.success', { accountId, url: options.url });
                     (0, metrics_1.incrementMetric)('httpSuccess');
+                    try {
+                        (0, request_history_1.recordRequest)({
+                            operation: op,
+                            selector: options.url,
+                            status: res.status ?? 200,
+                            durationMs: Date.now() - started,
+                            accountId,
+                        });
+                    }
+                    catch { }
                     return (await res.json());
                 }
                 const status = res.status ?? 0;
@@ -86,18 +121,44 @@ async function executeLinkedInRequest(options, _operationName) {
                     catch { }
                     (0, logger_1.log)('warn', 'http.rotateOnAuth', { accountId, status });
                     (0, metrics_1.incrementMetric)('authErrors');
+                    (0, metrics_1.incrementMetric)('httpFailures');
                     lastError = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, 'REQUEST_FAILED', status, accountId);
+                    try {
+                        (0, request_history_1.recordRequest)({
+                            operation: op,
+                            selector: options.url,
+                            status,
+                            durationMs: Date.now() - started,
+                            accountId,
+                            errorMessage: 'rotate',
+                        });
+                    }
+                    catch { }
                     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, logger_1.log)('debug', 'http.retry', { accountId, status, attempt: attempt + 1, 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);
+                const err = new errors_1.LinkedInClientError(`LinkedIn request failed: ${status}`, 'REQUEST_FAILED', status, accountId);
+                (0, metrics_1.incrementMetric)('httpFailures');
+                (0, logger_1.log)(status >= 500 ? 'warn' : 'error', 'http.fail', { accountId, status, url: options.url });
+                try {
+                    (0, request_history_1.recordRequest)({
+                        operation: op,
+                        selector: options.url,
+                        status,
+                        durationMs: Date.now() - started,
+                        accountId,
+                        errorMessage: err.message,
+                    });
+                }
+                catch { }
+                throw err;
             }
         }
         // Exhausted rotations
@@ -116,6 +177,51 @@ async function executeLinkedInRequest(options, _operationName) {
                 delete process.env.HTTPS_PROXY;
             else
                 process.env.HTTPS_PROXY = prevHttps;
+            (0, logger_1.log)('info', 'proxy.restore', {});
         }
     }
 }
+// Parse proxy string supporting:
+// - Full URL forms: http(s)://[user[:pass]@]host:port (host may be [ipv6])
+// - Colon-delimited: host:port[:user:pass] with optional [ipv6]
+function parseProxyString(input) {
+    const s = String(input).trim();
+    // URL form
+    if (/^\w+:\/\//.test(s)) {
+        try {
+            const u = new URL(s);
+            if (u.protocol !== 'http:' && u.protocol !== 'https:') {
+                throw new errors_1.LinkedInClientError(`Unsupported proxy protocol: ${u.protocol}`, 'INVALID_CONFIG', 400);
+            }
+            const user = u.username || '';
+            const pass = u.password || '';
+            const hostport = u.host; // includes brackets for IPv6
+            const url = `${u.protocol}//${user ? `${user}:${pass}@` : ''}${hostport}`;
+            const masked = user ? `${hostport}:${user}:***` : hostport;
+            return { url, masked };
+        }
+        catch {
+            // fall through to colon parsing
+        }
+    }
+    // Colon-delimited
+    // [ipv6]:port[:user:pass] OR host:port[:user:pass]
+    const m = s.match(/^(\[?[^\]]+\]?):(\d+)(?::([^:]*):(.+))?$/);
+    if (m) {
+        let host = m[1];
+        const port = m[2];
+        const user = m[3];
+        const pass = m[4];
+        // Ensure brackets for IPv6 in URL
+        const needsBrackets = host.includes(':') && !/^\[.*\]$/.test(host);
+        if (needsBrackets)
+            host = `[${host}]`;
+        const auth = user && pass ? `${user}:${pass}@` : '';
+        const url = `http://${auth}${host}:${port}`;
+        const hostport = `${host}:${port}`;
+        const masked = user && pass ? `${hostport}:${user}:***` : hostport;
+        return { url, masked };
+    }
+    // Fallback: conservative
+    return { url: s.includes('://') ? s : `http://${s}`, masked: '***' };
+}

package/dist/index.d.ts

@@ -8,3 +8,5 @@ export { parseSalesSearchResults } from './parsers/search-parser';
 export * from './linkedin-api';
 export * from './types';
 export * from './utils/metrics';
+export { getRequestHistory, clearRequestHistory } from './utils/request-history';
+export type { RequestHistoryEntry } from './utils/request-history';

package/dist/index.js

@@ -14,7 +14,7 @@ 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;
+exports.clearRequestHistory = exports.getRequestHistory = 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; } });
@@ -29,3 +29,6 @@ Object.defineProperty(exports, "parseSalesSearchResults", { enumerable: true, ge
 __exportStar(require("./linkedin-api"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/metrics"), exports);
+var request_history_1 = require("./utils/request-history");
+Object.defineProperty(exports, "getRequestHistory", { enumerable: true, get: function () { return request_history_1.getRequestHistory; } });
+Object.defineProperty(exports, "clearRequestHistory", { enumerable: true, get: function () { return request_history_1.clearRequestHistory; } });

package/dist/linkedin-api.d.ts

@@ -1,5 +1,24 @@
-import type { LinkedInProfile, SalesLeadSearchResult } from './types';
+import type { SalesSearchFilters } from './types';
+import type { LinkedInProfile, SalesLeadSearchResult, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, Company } 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[]>;
+export declare function searchSalesLeads(keywords: string, options?: {
+    start?: number;
+    count?: number;
+    decorationId?: string;
+    filters?: SalesSearchFilters;
+    rawQuery?: string;
+}): Promise<SearchSalesResult | SalesLeadSearchResult[]>;
+export declare function getProfilesBatch(vanities: string[], concurrency?: number): Promise<(LinkedInProfile | null)[]>;
+export declare function resolveCompanyUniversalName(universalName: string): Promise<{
+    companyId?: string;
+}>;
+export declare function getCompanyById(companyId: string): Promise<Company>;
+export declare function getCompanyByUrl(companyUrl: string): Promise<Company>;
+export declare function typeahead(options: {
+    type: string;
+    query?: string;
+    start?: number;
+    count?: number;
+}): Promise<TypeaheadResult>;
+export declare function getSalesNavigatorProfileDetails(profileUrnOrId: string): Promise<SalesNavigatorProfile>;