linkedin-secret-sauce 0.12.5 → 0.13.0

package/dist/linkedin-api.js

@@ -37,6 +37,7 @@ exports.COMPANY_SIZE_OPTIONS = exports.INDUSTRY_OPTIONS = exports.LANGUAGE_OPTIO
 exports.getProfileByVanity = getProfileByVanity;
 exports.getProfileByUrn = getProfileByUrn;
 exports.searchSalesLeads = searchSalesLeads;
+exports.analyzeProfilePosts = analyzeProfilePosts;
 exports.getProfilesBatch = getProfilesBatch;
 exports.resolveCompanyUniversalName = resolveCompanyUniversalName;
 exports.getCompanyById = getCompanyById;
@@ -49,6 +50,9 @@ exports.getYearsOfExperienceOptions = getYearsOfExperienceOptions;
 exports.getSalesNavigatorProfileDetails = getSalesNavigatorProfileDetails;
 exports.getSalesNavigatorProfileFull = getSalesNavigatorProfileFull;
 exports.extractLinkedInHandle = extractLinkedInHandle;
+exports.getPostReactions = getPostReactions;
+exports.getPostComments = getPostComments;
+exports.getPostHistory = getPostHistory;
 const config_1 = require("./config");
 const http_client_1 = require("./http-client");
 const profile_parser_1 = require("./parsers/profile-parser");
@@ -93,7 +97,10 @@ const inflightByVanity = new Map();
  */
 async function getProfileByVanity(vanity) {
     const cfg = (0, config_1.getConfig)();
-    const key = String(vanity || "").toLowerCase();
+    // Extract vanity from LinkedIn URL if full URL is provided
+    const input = String(vanity || "").trim();
+    const urlMatch = input.match(/linkedin\.com\/in\/([^/?#]+)/i);
+    const key = (urlMatch ? decodeURIComponent(urlMatch[1]) : input).toLowerCase();
     try {
         (0, logger_1.log)("info", "api.start", {
             operation: "getProfileByVanity",
@@ -113,7 +120,7 @@ async function getProfileByVanity(vanity) {
         (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 url = `${LINKEDIN_API_BASE}/identity/dash/profiles?q=memberIdentity&memberIdentity=${encodeURIComponent(key)}&decorationId=com.linkedin.voyager.dash.deco.identity.profile.FullProfileWithEntities-35`;
     const p = (async () => {
         try {
             let raw;
@@ -137,7 +144,7 @@ async function getProfileByVanity(vanity) {
             }
             let prof;
             try {
-                prof = (0, profile_parser_1.parseFullProfile)(raw, vanity);
+                prof = (0, profile_parser_1.parseFullProfile)(raw, key);
             }
             catch {
                 try {
@@ -468,6 +475,199 @@ async function searchSalesLeads(keywords, options) {
     (0, metrics_1.incrementMetric)("searchCacheMisses");
     return result;
 }
+// ---------------------------------------------------------------------------
+// High-Level Convenience API
+// ---------------------------------------------------------------------------
+/**
+ * Analyzes a LinkedIn profile's posts with engagement data (reactions and comments).
+ * This is a high-level convenience function that orchestrates multiple API calls:
+ * 1. Fetches the profile by vanity URL or URN
+ * 2. Retrieves the profile's post history
+ * 3. Fetches reactions and comments for each post
+ *
+ * @param profileIdentifier - LinkedIn vanity URL, full profile URL, or FSD profile URN
+ * @param options - Analysis options for controlling fetch behavior
+ * @returns Complete analysis result with profile, posts, engagement data, and summary statistics
+ *
+ * @example
+ * ```typescript
+ * // Analyze by vanity URL
+ * const analysis = await analyzeProfilePosts('john-doe');
+ * console.log(analysis.summary.totalReactions);
+ * console.log(analysis.summary.avgCommentsPerPost);
+ *
+ * // Analyze by full LinkedIn URL
+ * const analysis = await analyzeProfilePosts('https://www.linkedin.com/in/john-doe');
+ *
+ * // Analyze with options
+ * const analysis = await analyzeProfilePosts('john-doe', {
+ *   postsCount: 20,
+ *   reactionsPerPost: 50,
+ *   commentsPerPost: 25,
+ *   concurrency: 5,
+ * });
+ *
+ * // Access individual post engagement
+ * for (const analyzed of analysis.analyzedPosts) {
+ *   console.log(`Post: ${analyzed.post.text?.substring(0, 50)}...`);
+ *   console.log(`  Reactions: ${analyzed.reactions.totalCount}`);
+ *   console.log(`  Comments: ${analyzed.comments.totalCount}`);
+ * }
+ * ```
+ */
+async function analyzeProfilePosts(profileIdentifier, options) {
+    const postsCount = Math.min(options?.postsCount ?? 10, 100);
+    const reactionsPerPost = Math.min(options?.reactionsPerPost ?? 10, 100);
+    const commentsPerPost = Math.min(options?.commentsPerPost ?? 10, 100);
+    const concurrency = Math.max(1, Math.min(options?.concurrency ?? 3, 10));
+    const skipReactions = options?.skipReactions ?? false;
+    const skipComments = options?.skipComments ?? false;
+    try {
+        (0, logger_1.log)("info", "api.start", {
+            operation: "analyzeProfilePosts",
+            selector: profileIdentifier,
+            options: { postsCount, reactionsPerPost, commentsPerPost, concurrency },
+        });
+    }
+    catch { }
+    // Step 1: Fetch profile
+    const input = String(profileIdentifier || "").trim();
+    let profile;
+    // Determine if it's a URN or vanity
+    const isUrn = input.startsWith("urn:li:") || /^[A-Za-z0-9_-]{20,}$/.test(input);
+    const isUrl = input.includes("linkedin.com/in/");
+    if (isUrn && !isUrl) {
+        profile = await getProfileByUrn(input);
+    }
+    else {
+        // Extract vanity from URL or use as-is
+        profile = await getProfileByVanity(input);
+    }
+    // Step 2: Fetch post history
+    const fsdKey = profile.fsdProfileUrn?.replace("urn:li:fsd_profile:", "") ||
+        profile.objectUrn?.replace("urn:li:member:", "");
+    if (!fsdKey) {
+        throw new errors_1.LinkedInClientError("Could not extract profile key for post history", errors_1.ERROR_CODES.PARSE_ERROR, 500);
+    }
+    const postHistory = await getPostHistory(fsdKey, { count: postsCount });
+    // Step 3: Fetch engagement data for each post with controlled concurrency
+    const analyzedPosts = [];
+    const postsToAnalyze = postHistory.posts.filter((p) => p.activityUrn);
+    // Worker function for concurrent processing
+    let idx = 0;
+    async function worker() {
+        while (idx < postsToAnalyze.length) {
+            const myIdx = idx++;
+            const post = postsToAnalyze[myIdx];
+            if (!post.activityUrn)
+                continue;
+            let reactions = {
+                reactions: [],
+                totalCount: 0,
+                page: { start: 0, count: 0, total: 0, hasMore: false },
+            };
+            let comments = {
+                comments: [],
+                totalCount: 0,
+                page: { start: 0, count: 0, total: 0, hasMore: false },
+            };
+            // Fetch reactions if not skipped
+            if (!skipReactions) {
+                try {
+                    reactions = await getPostReactions(post.activityUrn, {
+                        count: reactionsPerPost,
+                    });
+                }
+                catch (e) {
+                    try {
+                        (0, logger_1.log)("warn", "api.analyzeProfilePosts.reactionsFailed", {
+                            activityUrn: post.activityUrn,
+                            error: e.message,
+                        });
+                    }
+                    catch { }
+                }
+            }
+            // Fetch comments if not skipped
+            if (!skipComments) {
+                try {
+                    comments = await getPostComments(post.activityUrn, {
+                        commentsCount: commentsPerPost,
+                    });
+                }
+                catch (e) {
+                    try {
+                        (0, logger_1.log)("warn", "api.analyzeProfilePosts.commentsFailed", {
+                            activityUrn: post.activityUrn,
+                            error: e.message,
+                        });
+                    }
+                    catch { }
+                }
+            }
+            analyzedPosts[myIdx] = { post, reactions, comments };
+        }
+    }
+    // Run workers concurrently
+    const workers = Array.from({ length: Math.min(concurrency, postsToAnalyze.length) }, () => worker());
+    await Promise.all(workers);
+    // Filter out any undefined entries (shouldn't happen, but be safe)
+    const validAnalyzedPosts = analyzedPosts.filter((p) => p !== undefined);
+    // Step 4: Calculate summary statistics
+    let totalReactions = 0;
+    let totalComments = 0;
+    const reactionsByType = {
+        LIKE: 0,
+        CELEBRATE: 0,
+        SUPPORT: 0,
+        LOVE: 0,
+        INSIGHTFUL: 0,
+        FUNNY: 0,
+        INTEREST: 0,
+        APPRECIATION: 0,
+        PRAISE: 0,
+        EMPATHY: 0,
+        ENTERTAINMENT: 0,
+    };
+    for (const analyzed of validAnalyzedPosts) {
+        totalReactions += analyzed.reactions.totalCount;
+        totalComments += analyzed.comments.totalCount;
+        for (const reaction of analyzed.reactions.reactions) {
+            if (reaction.reactionType) {
+                reactionsByType[reaction.reactionType] =
+                    (reactionsByType[reaction.reactionType] || 0) + 1;
+            }
+        }
+    }
+    const totalPosts = validAnalyzedPosts.length;
+    const avgReactionsPerPost = totalPosts > 0 ? totalReactions / totalPosts : 0;
+    const avgCommentsPerPost = totalPosts > 0 ? totalComments / totalPosts : 0;
+    const result = {
+        profile,
+        analyzedPosts: validAnalyzedPosts,
+        summary: {
+            totalPosts,
+            totalReactions,
+            totalComments,
+            avgReactionsPerPost: Math.round(avgReactionsPerPost * 100) / 100,
+            avgCommentsPerPost: Math.round(avgCommentsPerPost * 100) / 100,
+            reactionsByType,
+        },
+    };
+    try {
+        (0, logger_1.log)("info", "api.ok", {
+            operation: "analyzeProfilePosts",
+            selector: profileIdentifier,
+            summary: {
+                totalPosts,
+                totalReactions,
+                totalComments,
+            },
+        });
+    }
+    catch { }
+    return result;
+}
 async function getProfilesBatch(vanities, concurrency = 4) {
     const limit = Math.max(1, Math.min(concurrency || 1, 16));
     const results = Array.from({ length: vanities.length }, () => null);
@@ -1053,3 +1253,636 @@ function extractLinkedInHandle(flagshipProfileUrl) {
     const match = flagshipProfileUrl.match(/linkedin\.com\/in\/([^\/\?]+)/i);
     return match ? match[1] : null;
 }
+// ---------------------------------------------------------------------------
+// Post Engagement APIs (Voyager GraphQL)
+// ---------------------------------------------------------------------------
+// GraphQL query IDs for post engagement endpoints (discovered via network inspection)
+const REACTIONS_QUERY_ID = "voyagerSocialDashReactions.41ebf31a9f4c4a84e35a49d5abc9010b";
+// Comments use voyagerFeedDashUpdates endpoint (not voyagerSocialDashComments which returns 400)
+const FEED_UPDATES_QUERY_ID = "voyagerFeedDashUpdates.ca43379417f0bcc4a7e2031d6c063250";
+/**
+ * Parses LinkedIn relative time strings into approximate Unix timestamps.
+ * LinkedIn returns times like "2d", "1w", "3mo", "1yr" instead of absolute timestamps.
+ *
+ * @param relativeText - Relative time string (e.g., "2d", "1w", "3mo", "2 days ago")
+ * @returns Unix timestamp in milliseconds, or undefined if parsing fails
+ */
+function parseRelativeTime(relativeText) {
+    if (!relativeText)
+        return undefined;
+    const now = Date.now();
+    const text = relativeText.toLowerCase().trim();
+    // Match patterns like "2d", "1w", "3mo", "1yr", "2 days ago", "1 week ago", etc.
+    // Also handles "2d •" format (with trailing bullet)
+    const match = text.match(/^(\d+)\s*(s|m|h|d|w|mo|yr|sec|min|hour|day|week|month|year)s?\b/i);
+    if (!match) {
+        // Try "X time ago" format
+        const agoMatch = text.match(/(\d+)\s*(second|minute|hour|day|week|month|year)s?\s*ago/i);
+        if (!agoMatch)
+            return undefined;
+        const [, numStr, unit] = agoMatch;
+        const num = parseInt(numStr, 10);
+        if (isNaN(num))
+            return undefined;
+        const msPerUnit = {
+            second: 1000,
+            minute: 60 * 1000,
+            hour: 60 * 60 * 1000,
+            day: 24 * 60 * 60 * 1000,
+            week: 7 * 24 * 60 * 60 * 1000,
+            month: 30 * 24 * 60 * 60 * 1000,
+            year: 365 * 24 * 60 * 60 * 1000,
+        };
+        const unitKey = unit.toLowerCase();
+        const ms = msPerUnit[unitKey];
+        if (!ms)
+            return undefined;
+        return now - num * ms;
+    }
+    const [, numStr, unit] = match;
+    const num = parseInt(numStr, 10);
+    if (isNaN(num))
+        return undefined;
+    // Map short units to milliseconds
+    const msPerUnit = {
+        s: 1000,
+        sec: 1000,
+        m: 60 * 1000,
+        min: 60 * 1000,
+        h: 60 * 60 * 1000,
+        hour: 60 * 60 * 1000,
+        d: 24 * 60 * 60 * 1000,
+        day: 24 * 60 * 60 * 1000,
+        w: 7 * 24 * 60 * 60 * 1000,
+        week: 7 * 24 * 60 * 60 * 1000,
+        mo: 30 * 24 * 60 * 60 * 1000,
+        month: 30 * 24 * 60 * 60 * 1000,
+        yr: 365 * 24 * 60 * 60 * 1000,
+        year: 365 * 24 * 60 * 60 * 1000,
+    };
+    const unitKey = unit.toLowerCase();
+    const ms = msPerUnit[unitKey];
+    if (!ms)
+        return undefined;
+    return now - num * ms;
+}
+/**
+ * Extracts the activity ID from various LinkedIn URN formats.
+ * @param activityUrnOrId - Activity URN (urn:li:activity:xxx) or bare ID
+ * @returns The numeric activity ID
+ */
+function extractActivityId(activityUrnOrId) {
+    const input = String(activityUrnOrId || "").trim();
+    // Match urn:li:activity:1234567890
+    const urnMatch = input.match(/^urn:li:activity:(\d+)$/i);
+    if (urnMatch)
+        return urnMatch[1];
+    // Match bare numeric ID
+    if (/^\d+$/.test(input))
+        return input;
+    throw new errors_1.LinkedInClientError("Invalid activity URN or ID format", errors_1.ERROR_CODES.INVALID_INPUT, 400);
+}
+/**
+ * Fetches reactions (likes, celebrates, etc.) for a LinkedIn post.
+ * Uses the Voyager GraphQL API with pagination support.
+ *
+ * @param activityUrn - The activity URN (e.g., "urn:li:activity:7419061111293083648") or bare ID
+ * @param options - Pagination options
+ * @param options.start - Pagination offset (default: 0)
+ * @param options.count - Number of reactions to fetch (default: 10, max: 100)
+ * @returns PostReactionsResult with reactions array and pagination info
+ * @throws LinkedInClientError with code NOT_FOUND if post doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 reactions
+ * const reactions = await getPostReactions('urn:li:activity:7419061111293083648');
+ * console.log(reactions.totalCount); // 37
+ * console.log(reactions.reactions[0].reactionType); // "LIKE"
+ *
+ * // Paginate through all reactions
+ * const page2 = await getPostReactions('7419061111293083648', { start: 10, count: 10 });
+ * ```
+ */
+async function getPostReactions(activityUrn, options) {
+    const activityId = extractActivityId(activityUrn);
+    const start = Number.isFinite(options?.start) ? Number(options.start) : 0;
+    const count = Math.min(Number.isFinite(options?.count) ? Number(options.count) : 10, 100);
+    const threadUrn = `urn:li:activity:${activityId}`;
+    const variables = `(count:${count},start:${start},threadUrn:${encodeURIComponent(threadUrn)})`;
+    const url = `${LINKEDIN_API_BASE}/graphql?includeWebMetadata=true&variables=${variables}&queryId=${REACTIONS_QUERY_ID}`;
+    try {
+        (0, logger_1.log)("info", "api.start", {
+            operation: "getPostReactions",
+            selector: { activityId, start, count },
+        });
+    }
+    catch { }
+    let raw;
+    try {
+        raw = await (0, http_client_1.executeLinkedInRequest)({ url }, "getPostReactions");
+    }
+    catch (e) {
+        const status = e?.status ?? 0;
+        if (status === 404) {
+            try {
+                (0, logger_1.log)("warn", "api.notFound", {
+                    operation: "getPostReactions",
+                    selector: activityId,
+                    status,
+                });
+            }
+            catch { }
+            throw new errors_1.LinkedInClientError("Post not found", errors_1.ERROR_CODES.NOT_FOUND, 404);
+        }
+        throw e;
+    }
+    // Parse the GraphQL response
+    // Response structure: { data: { data: { socialDashReactionsByReactionType: { paging, *elements } } } }
+    const rr = raw;
+    const outerData = rr?.data;
+    const innerData = outerData?.data;
+    const reactionsData = innerData?.socialDashReactionsByReactionType;
+    // Extract paging info
+    const paging = reactionsData?.paging;
+    const total = paging?.total ?? 0;
+    // Extract reactions from *elements (note the asterisk prefix)
+    // Format: "urn:li:fsd_reaction:(urn:li:fsd_profile:ABC,urn:li:activity:123,0)"
+    // The last number (0) is the reaction type: 0=LIKE, 1=CELEBRATE, 2=SUPPORT, 3=LOVE, 4=INSIGHTFUL, 5=FUNNY
+    const elementsRefs = reactionsData?.["*elements"] || [];
+    const reactions = [];
+    const reactionTypeMap = {
+        "0": "LIKE",
+        "1": "CELEBRATE",
+        "2": "SUPPORT",
+        "3": "LOVE",
+        "4": "INSIGHTFUL",
+        "5": "FUNNY",
+    };
+    for (const urn of elementsRefs) {
+        if (!urn || typeof urn !== "string")
+            continue;
+        // Parse URN: urn:li:fsd_reaction:(urn:li:fsd_profile:ABC,urn:li:activity:123,0)
+        const match = urn.match(/fsd_reaction:\(([^,]+),([^,]+),(\d+)\)/);
+        if (!match)
+            continue;
+        const [, actorUrn, , reactionTypeNum] = match;
+        const reactionType = reactionTypeMap[reactionTypeNum] || "LIKE";
+        // Extract actor URN (profile or company)
+        const isCompany = actorUrn?.includes("fsd_company:");
+        const actorId = actorUrn?.match(/:([\w-]+)$/)?.[1];
+        reactions.push({
+            reactionType,
+            actor: actorId
+                ? {
+                    entityUrn: actorUrn,
+                    isCompany,
+                }
+                : undefined,
+        });
+    }
+    const result = {
+        reactions,
+        totalCount: total,
+        page: {
+            start,
+            count,
+            total,
+            hasMore: start + count < total,
+        },
+    };
+    try {
+        (0, logger_1.log)("info", "api.ok", {
+            operation: "getPostReactions",
+            selector: activityId,
+            totalCount: total,
+            fetchedCount: reactions.length,
+        });
+    }
+    catch { }
+    return result;
+}
+/**
+ * Fetches comments for a LinkedIn post.
+ * Uses the voyagerFeedDashUpdates GraphQL API.
+ *
+ * @param activityUrn - The activity URN (e.g., "urn:li:activity:7419061111293083648") or bare ID
+ * @param options - Fetch options
+ * @param options.commentsCount - Number of comments to fetch (default: 10, max: 100)
+ * @returns PostCommentsResult with comments array
+ * @throws LinkedInClientError with code NOT_FOUND if post doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Get comments for a post
+ * const comments = await getPostComments('urn:li:activity:7419061111293083648');
+ * console.log(comments.totalCount);
+ *
+ * // Get more comments
+ * const moreComments = await getPostComments('7419061111293083648', { commentsCount: 50 });
+ * ```
+ */
+async function getPostComments(activityUrn, options) {
+    const activityId = extractActivityId(activityUrn);
+    const commentsCount = Math.min(Number.isFinite(options?.commentsCount)
+        ? Number(options.commentsCount)
+        : 10, 100);
+    // Build variables for voyagerFeedDashUpdates endpoint
+    // Format: (commentsCount:10,likesCount:10,includeCommentsFirstReply:true,includeReactions:false,moduleKey:feed-item:desktop,urnOrNss:urn:li:activity:XXX)
+    const activityUrnFull = `urn:li:activity:${activityId}`;
+    const variables = `(commentsCount:${commentsCount},likesCount:10,includeCommentsFirstReply:true,includeReactions:false,moduleKey:feed-item%3Adesktop,urnOrNss:${encodeURIComponent(activityUrnFull)})`;
+    const url = `${LINKEDIN_API_BASE}/graphql?includeWebMetadata=true&variables=${variables}&queryId=${FEED_UPDATES_QUERY_ID}`;
+    try {
+        (0, logger_1.log)("info", "api.start", {
+            operation: "getPostComments",
+            selector: { activityId, commentsCount },
+        });
+    }
+    catch { }
+    let raw;
+    try {
+        raw = await (0, http_client_1.executeLinkedInRequest)({ url }, "getPostComments");
+    }
+    catch (e) {
+        const status = e?.status ?? 0;
+        if (status === 404) {
+            try {
+                (0, logger_1.log)("warn", "api.notFound", {
+                    operation: "getPostComments",
+                    selector: activityId,
+                    status,
+                });
+            }
+            catch { }
+            throw new errors_1.LinkedInClientError("Post not found", errors_1.ERROR_CODES.NOT_FOUND, 404);
+        }
+        throw e;
+    }
+    // Parse the voyagerFeedDashUpdates GraphQL response
+    // Response has: { data: {...}, included: [...] }
+    const rr = raw;
+    const included = rr?.included;
+    const comments = [];
+    let totalCount = 0;
+    if (Array.isArray(included)) {
+        // Find comments in included array - they have $type containing "Comment"
+        for (const item of included) {
+            const type = item?.$type;
+            const entityUrn = item?.entityUrn;
+            // Look for comment entities
+            if (type && type.includes("Comment") && entityUrn?.includes("comment")) {
+                // Extract comment text - try multiple possible locations
+                let text;
+                // Try commentary.text.text (nested structure) or commentary.text directly
+                const commentaryObj = item.commentary;
+                if (commentaryObj) {
+                    const commentaryTextObj = commentaryObj.text;
+                    if (typeof commentaryTextObj === "string") {
+                        text = commentaryTextObj;
+                    }
+                    else if (commentaryTextObj &&
+                        typeof commentaryTextObj === "object") {
+                        text = commentaryTextObj.text;
+                    }
+                }
+                // Try content field
+                if (!text && item.content) {
+                    const contentObj = item.content;
+                    if (typeof contentObj === "string") {
+                        text = contentObj;
+                    }
+                    else if (contentObj && typeof contentObj === "object") {
+                        const contentText = contentObj.text;
+                        if (typeof contentText === "string") {
+                            text = contentText;
+                        }
+                        else if (contentText && typeof contentText === "object") {
+                            text = contentText.text;
+                        }
+                    }
+                }
+                // Try direct text field
+                if (!text) {
+                    text = item.commentText;
+                }
+                // Skip if no text found (probably a hide action or other non-comment entity)
+                if (!text)
+                    continue;
+                // Extract author info from commenter lockup
+                const commenterLockup = item.commenter;
+                const titleObj = commenterLockup?.title;
+                const authorName = titleObj?.text;
+                const subtitleObj = commenterLockup?.subtitle;
+                const authorHeadline = subtitleObj?.text;
+                // Extract profile URL
+                const navigationCtx = commenterLockup?.navigationContext;
+                const authorProfileUrl = navigationCtx?.url;
+                // Parse author name
+                let authorFirstName;
+                let authorLastName;
+                if (authorName) {
+                    const nameParts = authorName.split(" ");
+                    authorFirstName = nameParts[0];
+                    authorLastName = nameParts.slice(1).join(" ") || undefined;
+                }
+                const author = authorName
+                    ? {
+                        entityUrn: item.commenterProfileId,
+                        firstName: authorFirstName,
+                        lastName: authorLastName,
+                        headline: authorHeadline,
+                        profileUrl: authorProfileUrl,
+                    }
+                    : undefined;
+                // Extract engagement metrics
+                const socialDetail = item.socialDetail;
+                const totalCounts = socialDetail?.totalSocialActivityCounts;
+                const numLikes = totalCounts?.numLikes ??
+                    item.numLikes;
+                const numReplies = totalCounts?.numComments ??
+                    item.numReplies;
+                // Extract timestamp
+                const createdAt = item.createdTime;
+                comments.push({
+                    entityUrn,
+                    text,
+                    author,
+                    createdAt,
+                    numLikes,
+                    numReplies,
+                });
+            }
+            // Also look for social counts to get total comment count
+            if (entityUrn?.includes("socialActivityCounts") &&
+                entityUrn.includes(activityId)) {
+                totalCount = item.numComments ?? totalCount;
+            }
+        }
+    }
+    // If we didn't find totalCount from socialActivityCounts, use the comments array length
+    if (totalCount === 0) {
+        totalCount = comments.length;
+    }
+    const result = {
+        comments,
+        totalCount,
+        page: {
+            start: 0,
+            count: commentsCount,
+            total: totalCount,
+            hasMore: comments.length < totalCount,
+        },
+    };
+    try {
+        (0, logger_1.log)("info", "api.ok", {
+            operation: "getPostComments",
+            selector: activityId,
+            totalCount,
+            fetchedCount: comments.length,
+        });
+    }
+    catch { }
+    return result;
+}
+/**
+ * Fetches a user's post history (their published posts).
+ * Uses the Voyager profileUpdatesV2 API with pagination support.
+ *
+ * @param profileUrn - The FSD profile URN (e.g., "urn:li:fsd_profile:ABC123xyz") or bare key
+ * @param options - Pagination options
+ * @param options.start - Pagination offset (default: 0)
+ * @param options.count - Number of posts to fetch (default: 10, max: 100)
+ * @returns PostHistoryResult with posts array and pagination info
+ * @throws LinkedInClientError with code NOT_FOUND if profile doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 posts
+ * const posts = await getPostHistory('ABC123xyz');
+ * console.log(posts.posts.length);
+ *
+ * // Paginate
+ * const page2 = await getPostHistory('ABC123xyz', { start: 10, count: 10 });
+ * ```
+ */
+async function getPostHistory(profileUrn, options) {
+    const input = String(profileUrn || "").trim();
+    // Extract FSD key from various URN formats
+    const keyMatch = input.match(/^urn:li:fsd_profile:([^\s/]+)$/i)?.[1] ||
+        input.match(/^urn:li:fs_salesProfile:\(([^,\s)]+)/i)?.[1] ||
+        (input.match(/^[A-Za-z0-9_-]+$/) ? input : null);
+    if (!keyMatch) {
+        throw new errors_1.LinkedInClientError("Invalid profile URN or key", errors_1.ERROR_CODES.INVALID_INPUT, 400);
+    }
+    const start = Number.isFinite(options?.start) ? Number(options.start) : 0;
+    const count = Math.min(Number.isFinite(options?.count) ? Number(options.count) : 10, 100);
+    const profileUrnEncoded = encodeURIComponent(`urn:li:fsd_profile:${keyMatch}`);
+    const url = `${LINKEDIN_API_BASE}/identity/profileUpdatesV2?count=${count}&includeLongTermHistory=true&moduleKey=member-shares%3Aphone&profileUrn=${profileUrnEncoded}&q=memberShareFeed&start=${start}`;
+    try {
+        (0, logger_1.log)("info", "api.start", {
+            operation: "getPostHistory",
+            selector: { profileKey: keyMatch, start, count },
+        });
+    }
+    catch { }
+    let raw;
+    try {
+        raw = await (0, http_client_1.executeLinkedInRequest)({ url }, "getPostHistory");
+    }
+    catch (e) {
+        const status = e?.status ?? 0;
+        if (status === 404) {
+            try {
+                (0, logger_1.log)("warn", "api.notFound", {
+                    operation: "getPostHistory",
+                    selector: keyMatch,
+                    status,
+                });
+            }
+            catch { }
+            throw new errors_1.LinkedInClientError("Profile not found", errors_1.ERROR_CODES.NOT_FOUND, 404);
+        }
+        throw e;
+    }
+    // Parse the response
+    const rr = raw;
+    // The response can have two formats:
+    // 1. Old format: { elements: [...], paging: {...} }
+    // 2. New dash format: { data: {...}, included: [...] }
+    const included = rr?.included;
+    const dataObj = rr?.data;
+    // Extract paging info
+    const paging = (dataObj?.paging || rr?.paging);
+    const total = paging?.total;
+    // Extract posts - handle both formats
+    let elements = [];
+    if (Array.isArray(rr?.elements)) {
+        // Old format
+        elements = rr.elements;
+    }
+    else if (Array.isArray(included)) {
+        // New dash format - posts are in included array with specific $type
+        const dataElements = dataObj?.elements;
+        if (Array.isArray(dataElements)) {
+            elements = dataElements;
+        }
+        else {
+            // Filter included array for update/activity types
+            elements = included.filter((item) => {
+                const type = item?.$type;
+                return (type &&
+                    (type.includes("Update") ||
+                        type.includes("Activity") ||
+                        type.includes("share") ||
+                        type.includes("Share")));
+            });
+        }
+    }
+    const posts = [];
+    // Build a map of activity URN -> relative time from actor.subDescription
+    // LinkedIn returns relative time like "2d", "1w", "3mo" instead of absolute timestamps
+    const relativeTimeMap = new Map();
+    if (Array.isArray(included)) {
+        for (const item of included) {
+            const entityUrn = item?.entityUrn;
+            if (!entityUrn?.includes("fs_updateV2:"))
+                continue;
+            const activityMatch = entityUrn.match(/activity:(\d+)/);
+            if (!activityMatch)
+                continue;
+            const activityUrn = `urn:li:activity:${activityMatch[1]}`;
+            const actor = item.actor;
+            const subDesc = actor?.subDescription;
+            const relativeText = subDesc?.text || subDesc?.accessibilityText;
+            if (relativeText) {
+                const timestamp = parseRelativeTime(relativeText);
+                if (timestamp) {
+                    relativeTimeMap.set(activityUrn, timestamp);
+                }
+            }
+        }
+    }
+    // Build a map of activity URN -> social counts from included array
+    const socialCountsMap = new Map();
+    if (Array.isArray(included)) {
+        for (const item of included) {
+            const urn = item?.entityUrn;
+            // Match fs_socialActivityCounts:urn:li:activity:XXX
+            if (urn && urn.includes("fs_socialActivityCounts")) {
+                const activityMatch = urn.match(/activity:(\d+)/);
+                if (activityMatch) {
+                    const activityUrn = `urn:li:activity:${activityMatch[1]}`;
+                    socialCountsMap.set(activityUrn, {
+                        numLikes: item?.numLikes,
+                        numComments: item?.numComments,
+                        numShares: item?.numShares,
+                    });
+                }
+            }
+        }
+    }
+    for (const elem of elements) {
+        const el = elem;
+        if (!el)
+            continue;
+        const entityUrn = el.entityUrn;
+        // Only process actual posts (fs_updateV2 with activity in URN)
+        // Skip action entries, socialActivityCounts, miniProfile, etc.
+        if (!entityUrn || !entityUrn.includes("fs_updateV2:"))
+            continue;
+        // Extract activity URN from entity URN
+        // Format: urn:li:fs_updateV2:(urn:li:activity:7418215535290662912,MEMBER_SHARES,...)
+        const activityMatch = entityUrn.match(/activity:(\d+)/);
+        const activityUrn = activityMatch
+            ? `urn:li:activity:${activityMatch[1]}`
+            : undefined;
+        // Extract text from commentary or directly
+        const commentary = el.commentary;
+        const textObj = commentary?.text;
+        let text = textObj?.text;
+        // Fallback: check direct text field
+        if (!text && el.text) {
+            text = el.text;
+        }
+        // Get social counts from map or from element directly
+        let numLikes;
+        let numComments;
+        let numShares;
+        if (activityUrn && socialCountsMap.has(activityUrn)) {
+            const counts = socialCountsMap.get(activityUrn);
+            numLikes = counts.numLikes;
+            numComments = counts.numComments;
+            numShares = counts.numShares;
+        }
+        else {
+            // Try extracting from socialDetail in the element
+            const socialDetail = el.socialDetail;
+            const socialCounts = socialDetail?.totalSocialActivityCounts;
+            numLikes = socialCounts?.numLikes;
+            numComments = socialCounts?.numComments;
+            numShares = socialCounts?.numShares;
+        }
+        // Extract timestamp - try multiple possible paths
+        let createdAt = el.createdTime;
+        if (!createdAt) {
+            // Try actor.timestamp or publishedAt
+            const actor = el.actor;
+            createdAt =
+                actor?.timestamp ||
+                    el.publishedAt ||
+                    el.createdAt;
+        }
+        // Fallback to parsed relative time from actor.subDescription (e.g., "2d", "1w")
+        if (!createdAt && activityUrn && relativeTimeMap.has(activityUrn)) {
+            createdAt = relativeTimeMap.get(activityUrn);
+        }
+        // Check if reshared
+        const resharedUpdate = el.resharedUpdate;
+        const reshared = !!resharedUpdate;
+        const originalPostUrn = resharedUpdate?.activityUrn;
+        // Only add posts that have text content (skip empty entries)
+        if (text || activityUrn) {
+            posts.push({
+                activityUrn,
+                entityUrn,
+                text,
+                createdAt,
+                numLikes,
+                numComments,
+                numShares,
+                reshared,
+                originalPostUrn,
+            });
+        }
+    }
+    // Deduplicate posts by activityUrn
+    const seenUrns = new Set();
+    const uniquePosts = posts.filter((p) => {
+        if (!p.activityUrn)
+            return true;
+        if (seenUrns.has(p.activityUrn))
+            return false;
+        seenUrns.add(p.activityUrn);
+        return true;
+    });
+    const hasMore = total ? start + count < total : elements.length === count;
+    const result = {
+        posts: uniquePosts,
+        page: {
+            start,
+            count,
+            total,
+            hasMore,
+        },
+    };
+    try {
+        (0, logger_1.log)("info", "api.ok", {
+            operation: "getPostHistory",
+            selector: keyMatch,
+            totalCount: total,
+            fetchedCount: uniquePosts.length,
+        });
+    }
+    catch { }
+    return result;
+}