@sellable/mcp 0.1.0

package/dist/tools/linkedin.d.ts

@@ -0,0 +1,210 @@
+export declare const linkedinToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            linkedinUrl: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            postUrl?: undefined;
+            sources?: undefined;
+            companyUrl?: undefined;
+            sortBy?: undefined;
+            linkedin_url?: undefined;
+            max_posts?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            postUrl: {
+                type: string;
+                description: string;
+            };
+            sources: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            linkedinUrl?: undefined;
+            companyUrl?: undefined;
+            sortBy?: undefined;
+            linkedin_url?: undefined;
+            max_posts?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            linkedinUrl: {
+                type: string;
+                description: string;
+            };
+            limit?: undefined;
+            postUrl?: undefined;
+            sources?: undefined;
+            companyUrl?: undefined;
+            sortBy?: undefined;
+            linkedin_url?: undefined;
+            max_posts?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            companyUrl: {
+                type: string;
+                description: string;
+            };
+            linkedinUrl?: undefined;
+            limit?: undefined;
+            postUrl?: undefined;
+            sources?: undefined;
+            sortBy?: undefined;
+            linkedin_url?: undefined;
+            max_posts?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            companyUrl: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            sortBy: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            linkedinUrl?: undefined;
+            postUrl?: undefined;
+            sources?: undefined;
+            linkedin_url?: undefined;
+            max_posts?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            linkedin_url: {
+                type: string;
+                description: string;
+            };
+            max_posts: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            linkedinUrl?: undefined;
+            limit?: undefined;
+            postUrl?: undefined;
+            sources?: undefined;
+            companyUrl?: undefined;
+            sortBy?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            linkedin_url: {
+                type: string;
+                description: string;
+            };
+            linkedinUrl?: undefined;
+            limit?: undefined;
+            postUrl?: undefined;
+            sources?: undefined;
+            companyUrl?: undefined;
+            sortBy?: undefined;
+            max_posts?: undefined;
+        };
+        required: string[];
+    };
+})[];
+interface SerializedPost {
+    text: string;
+    date: string;
+    reactions: number;
+    comments: number;
+    url: string;
+    isRepost: boolean;
+}
+export declare function fetchLinkedInPosts(linkedinUrl: string, limit?: number): Promise<{
+    posts: SerializedPost[];
+    count: number;
+}>;
+export declare function fetchLinkedInProfile(linkedinUrl: string): Promise<unknown>;
+export declare function fetchCompany(companyUrl: string): Promise<unknown>;
+export declare function fetchCompanyPosts(companyUrl: string, limit?: number, sortBy?: "recent" | "top"): Promise<{
+    posts: SerializedPost[];
+    count: number;
+}>;
+export declare function getUserPosts(linkedinUrl: string, maxPosts?: number): Promise<{
+    posts: SerializedPost[];
+    count: number;
+}>;
+export declare function getLinkedInProfile(linkedinUrl: string): Promise<unknown>;
+interface PostEngager {
+    name: string;
+    headline: string;
+    profileUrl: string;
+    source: "reaction" | "comment" | "both";
+    commentText?: string;
+}
+interface FetchPostEngagersResponse {
+    postId: string;
+    engagers: PostEngager[];
+    totalEngagers: number;
+    stats: {
+        reactionsCount: number;
+        commentsCount: number;
+        uniqueCount: number;
+        duplicatesRemoved: number;
+    };
+}
+export declare function fetchPostEngagers(postUrl: string, sources?: "reactions" | "comments" | "both", limit?: number): Promise<FetchPostEngagersResponse>;
+export {};

package/dist/tools/linkedin.js

@@ -0,0 +1,229 @@
+import { getApi } from "../api.js";
+export const linkedinToolDefinitions = [
+    {
+        name: "fetch_linkedin_posts",
+        description: "Fetch recent LinkedIn posts for a user profile. Returns compact serialized posts with: text, date, reactions, comments, url, isRepost.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                linkedinUrl: {
+                    type: "string",
+                    description: "Full LinkedIn profile URL",
+                },
+                limit: {
+                    type: "number",
+                    description: "Posts to return (default 25, max 50)",
+                    default: 25,
+                },
+            },
+            required: ["linkedinUrl"],
+        },
+    },
+    {
+        name: "fetch_post_engagers",
+        description: "Fetch people who engaged with a LinkedIn post (reactions and/or comments). Returns deduplicated engagers with name, headline, profileUrl, and source. Use 'comments' for lead magnets to get people who actively engaged. Uses smart rate limiting and parallel fetching.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postUrl: {
+                    type: "string",
+                    description: "Full LinkedIn post URL (e.g., https://www.linkedin.com/feed/update/activity:1234567890123456789)",
+                },
+                sources: {
+                    type: "string",
+                    enum: ["reactions", "comments", "both"],
+                    description: "Which engagement types to fetch. 'comments' for lead magnets (higher intent), 'reactions' for broader reach, 'both' for all engagers (default: both)",
+                    default: "both",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max engagers to return. For reactions max ~800, for comments max ~100, for both max ~900 (default: 600)",
+                    default: 600,
+                },
+            },
+            required: ["postUrl"],
+        },
+    },
+    {
+        name: "fetch_linkedin_profile",
+        description: "Fetch LinkedIn profile details from Sellable scrape endpoints.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                linkedinUrl: {
+                    type: "string",
+                    description: "Full LinkedIn profile URL",
+                },
+            },
+            required: ["linkedinUrl"],
+        },
+    },
+    {
+        name: "fetch_company",
+        description: "Fetch LinkedIn company profile details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                companyUrl: {
+                    type: "string",
+                    description: "LinkedIn company URL",
+                },
+            },
+            required: ["companyUrl"],
+        },
+    },
+    {
+        name: "fetch_company_posts",
+        description: "Fetch recent LinkedIn posts from a company page. Returns compact serialized posts with: text, date, reactions, comments, url, isRepost. Use this when asked to find posts by a company.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                companyUrl: {
+                    type: "string",
+                    description: "Full LinkedIn company URL (e.g., https://www.linkedin.com/company/amazon)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Posts to return (default 25, max 50)",
+                    default: 25,
+                },
+                sortBy: {
+                    type: "string",
+                    enum: ["recent", "top"],
+                    description: "Sort order: 'recent' for chronological (default), 'top' for highest engagement",
+                    default: "recent",
+                },
+            },
+            required: ["companyUrl"],
+        },
+    },
+    {
+        name: "get_user_posts",
+        description: "Fetch recent LinkedIn posts. Returns compact serialized posts with: text, date, reactions, comments, url, isRepost.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                linkedin_url: {
+                    type: "string",
+                    description: "Full LinkedIn profile URL",
+                },
+                max_posts: {
+                    type: "number",
+                    description: "Posts to return (default 25, max 50)",
+                    default: 25,
+                },
+            },
+            required: ["linkedin_url"],
+        },
+    },
+    {
+        name: "get_linkedin_profile",
+        description: "(Deprecated) Use fetch_linkedin_profile instead. Fetch LinkedIn profile details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                linkedin_url: {
+                    type: "string",
+                    description: "Full LinkedIn profile URL",
+                },
+            },
+            required: ["linkedin_url"],
+        },
+    },
+];
+export async function fetchLinkedInPosts(linkedinUrl, limit = 25) {
+    const api = getApi();
+    const params = new URLSearchParams({
+        linkedinUrl,
+        limit: String(limit),
+    });
+    const response = await api.get(`/api/v1/scrape/linkedin/user-posts?${params.toString()}`);
+    // Serialize to compact format: just text and key metadata
+    const posts = (response.posts || []).map((post) => ({
+        text: post.text || "",
+        date: post.activityDate || "",
+        reactions: post.reactionsCount || 0,
+        comments: post.commentsCount || 0,
+        url: post.activityUrl || "",
+        isRepost: post.isRepublishedPost || false,
+    }));
+    return {
+        posts,
+        count: posts.length,
+    };
+}
+export async function fetchLinkedInProfile(linkedinUrl) {
+    const api = getApi();
+    const params = new URLSearchParams({ linkedinUrl });
+    return api.get(`/api/v1/scrape/linkedin/profile?${params.toString()}`);
+}
+export async function fetchCompany(companyUrl) {
+    const api = getApi();
+    const params = new URLSearchParams({ linkedinUrl: companyUrl });
+    return api.get(`/api/v1/scrape/linkedin/company?${params.toString()}`);
+}
+export async function fetchCompanyPosts(companyUrl, limit = 25, sortBy = "recent") {
+    const api = getApi();
+    const params = new URLSearchParams({
+        linkedinUrl: companyUrl,
+        limit: String(limit),
+        sortBy,
+    });
+    const response = await api.get(`/api/v1/scrape/linkedin/company-posts?${params.toString()}`);
+    const posts = (response.posts || []).map((post) => ({
+        text: post.text || "",
+        date: post.activityDate || "",
+        reactions: post.reactionsCount || 0,
+        comments: post.commentsCount || 0,
+        url: post.activityUrl || "",
+        isRepost: post.isRepublishedPost || false,
+    }));
+    return {
+        posts,
+        count: posts.length,
+    };
+}
+// Deprecated aliases for backwards compatibility
+export async function getUserPosts(linkedinUrl, maxPosts = 25) {
+    return fetchLinkedInPosts(linkedinUrl, maxPosts);
+}
+export async function getLinkedInProfile(linkedinUrl) {
+    return fetchLinkedInProfile(linkedinUrl);
+}
+/**
+ * Extract LinkedIn activity ID from post URL.
+ * Handles various LinkedIn URL formats:
+ * - https://www.linkedin.com/feed/update/urn:li:activity:1234567890123456789
+ * - https://www.linkedin.com/feed/update/activity:1234567890123456789
+ * - https://www.linkedin.com/posts/username_activity-1234567890123456789
+ * - Direct activity ID: 1234567890123456789
+ */
+function extractActivityId(postUrl) {
+    const match = postUrl.match(/activity[:\-]?(\d{19})/i) || postUrl.match(/(\d{19})/);
+    return match?.[1] || null;
+}
+export async function fetchPostEngagers(postUrl, sources = "both", limit = 600) {
+    const api = getApi();
+    const activityId = extractActivityId(postUrl);
+    if (!activityId) {
+        throw new Error(`Invalid LinkedIn post URL. Could not extract activity ID from: ${postUrl}`);
+    }
+    // Cap limit based on source type
+    let cappedLimit;
+    if (sources === "comments") {
+        cappedLimit = Math.min(limit, 100); // Comments max 100
+    }
+    else if (sources === "reactions") {
+        cappedLimit = Math.min(limit, 800); // Reactions max 800
+    }
+    else {
+        cappedLimit = Math.min(limit, 900); // Both max 900
+    }
+    const response = await api.post("/api/v1/signal-discovery/fetch-all-engagers", {
+        postId: activityId,
+        postUrl,
+        limit: cappedLimit,
+        sources,
+    });
+    return response;
+}

package/dist/tools/navigation.d.ts

@@ -0,0 +1,91 @@
+export type GetCampaignNavigationStateInput = {
+    campaignId: string;
+    includeTableCheck?: boolean;
+};
+export type CampaignOfferNavigation = {
+    id: string;
+    clientProspectId?: string | null;
+    offerPositioning?: unknown;
+    campaignBrief?: {
+        content?: string | null;
+    } | string | null;
+    leadSourceType?: string | null;
+    leadSourceProvider?: string | null;
+    selectedLeadListId?: string | null;
+    workflowTableId?: string | null;
+    currentStep?: string | null;
+};
+type NavigationDebugPayload = Record<string, unknown>;
+export declare function logNavigationDebug(event: string, payload?: NavigationDebugPayload, campaignId?: string | null): void;
+type CreateCampaignStepId = "campaign-created" | "pick-provider" | "provider-search" | "confirm-lead-list";
+export declare const navigationToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            includeTableCheck: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+type NavigationComputeOptions = {
+    includeTableCheck: boolean;
+    tableChecked: boolean;
+    rowCount: number | null;
+    hasWorkflowRows: boolean | null;
+    initialWarnings?: string[];
+};
+export declare function computeCampaignNavigationStateFromCampaign(campaign: CampaignOfferNavigation, options: NavigationComputeOptions): {
+    campaignId: string;
+    computedStep: CreateCampaignStepId;
+    blockedAt: CreateCampaignStepId | null;
+    missing: string[];
+    expectedHeadlessStep: string | null;
+    headlessCurrentStep: string | null;
+    uiStep: string | null;
+    table: {
+        workflowTableId: string | null;
+        checked: boolean;
+        rowCount: number | null;
+        hasRows: boolean | null;
+    };
+    context: {
+        leadSourceType: string | null;
+        leadSourceProvider: string | null;
+        selectedLeadListId: string | null;
+        providerCurrentStep: string | null;
+    };
+    warnings: string[];
+};
+export declare function getCampaignNavigationState(input: GetCampaignNavigationStateInput): Promise<{
+    campaignId: string;
+    computedStep: CreateCampaignStepId;
+    blockedAt: CreateCampaignStepId | null;
+    missing: string[];
+    expectedHeadlessStep: string | null;
+    headlessCurrentStep: string | null;
+    uiStep: string | null;
+    table: {
+        workflowTableId: string | null;
+        checked: boolean;
+        rowCount: number | null;
+        hasRows: boolean | null;
+    };
+    context: {
+        leadSourceType: string | null;
+        leadSourceProvider: string | null;
+        selectedLeadListId: string | null;
+        providerCurrentStep: string | null;
+    };
+    warnings: string[];
+}>;
+export {};