@sellable/mcp 0.1.258 → 0.1.260

package/dist/server.js

@@ -18,7 +18,7 @@ import { copySenderConfigTool, getEngageMemoryTool, migrateFlatConfigsTool, reco
 import { getEngageStateTool, setEngageStateTool, } from "./tools/engage-state.js";
 import { bulkEnrichWithProspeo, enrichWithProspeo, getProspeoCredits, } from "./tools/enrichment.js";
 import { getCampaignFramework } from "./tools/framework.js";
-import { cancelLeadImport, confirmLeadList, confirmProspeoCompanyAccounts, getProviderPrompt, importLeads, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchProspeoCompanies, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
+import { cancelLeadImport, confirmLeadList, confirmProspeoCompanyAccounts, getProviderPrompt, importLeads, listDncEntriesTool, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchProspeoCompanies, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
 import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfile, fetchPostEngagers, getLinkedInProfile, getUserPosts, } from "./tools/linkedin.js";
 import { getCampaignNavigationState } from "./tools/navigation.js";
 import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDemandSequence, pauseOnDemandCampaign, startOnDemandCampaign, } from "./tools/one-off.js";
@@ -375,6 +375,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "load_csv_dnc_entries":
                 result = await loadCsvDncEntriesTool(args);
                 break;
+            case "list_dnc_entries":
+                result = await listDncEntriesTool(args);
+                break;
             case "save_domain_filters":
                 result = await saveDomainFilters(args);
                 break;

package/dist/tools/csv-dnc.d.ts

@@ -1,3 +1,4 @@
+type DncSourceType = "all" | "manual" | "hubspot";
 type InvalidDncRow = {
     row: number;
     column: string | null;
@@ -14,6 +15,41 @@ export type LoadCsvDncEntriesInput = {
     confirmationToken?: string;
     confirmed?: boolean;
 };
+export type ListDncEntriesInput = {
+    page?: number;
+    limit?: number;
+    search?: string;
+    listName?: string;
+    sourceType?: DncSourceType;
+    includeDeleted?: boolean;
+};
+export declare function listDncEntries(input?: ListDncEntriesInput): Promise<{
+    ok: boolean;
+    workspaceId: string;
+    workspaceName: string;
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    };
+    listNames: string[];
+    entries: {
+        id: string | null;
+        type: string;
+        domain: string | null;
+        linkedin: string | null;
+        linkedinUsername: string | null;
+        name: string | null;
+        source: {
+            type: string;
+            label: string;
+            listName: string | null;
+        };
+        createdAt: string | null;
+    }[];
+    guidance: string;
+}>;
 export declare function loadCsvDncEntries(input: LoadCsvDncEntriesInput): Promise<{
     guidance: string;
     createdCount: number;

package/dist/tools/csv-dnc.js

@@ -14,6 +14,7 @@ const CONFIRMATION_TOKEN_VERSION = "csv-dnc-preview-v1";
 const confirmationSecret = randomBytes(32).toString("hex");
 const MAX_DNC_UPLOAD_BYTES = 5 * 1024 * 1024;
 const MAX_DNC_CANDIDATES = 7500;
+const MAX_DNC_LIST_LIMIT = 100;
 const STRONG_DOMAIN_HEADER_KEYS = new Set([
     "domain",
     "website",
@@ -325,16 +326,84 @@ async function getVerifiedActiveWorkspace() {
     const config = getConfig();
     const activeWorkspaceId = config.activeWorkspaceId || config.workspaceId;
     if (!activeWorkspaceId) {
-        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before importing DNC entries.");
+        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace for the exact workspace whose Sellable DNC list should be read or updated.");
     }
     const api = getApi();
     const { workspaces } = await api.get("/api/v3/workspaces");
     const match = workspaces.find((workspace) => workspace.id === activeWorkspaceId);
     if (!match) {
-        throw new Error(`Active workspace ${activeWorkspaceId} is not in the server access list. Run list_workspaces then set_active_workspace for the workspace that should receive the DNC import.`);
+        throw new Error(`Active workspace ${activeWorkspaceId} is not in the server access list. Run list_workspaces then set_active_workspace for the exact workspace whose Sellable DNC list should be read or updated.`);
     }
     return match;
 }
+function clampListPositiveInt(value, fallback, max) {
+    const parsed = typeof value === "number"
+        ? value
+        : Number.parseInt(String(value ?? ""), 10);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return fallback;
+    return Math.min(Math.floor(parsed), max);
+}
+function normalizeDncSourceType(value) {
+    if (value === undefined || value === null || value === "")
+        return "all";
+    if (value === "all" || value === "manual" || value === "hubspot") {
+        return value;
+    }
+    throw new Error("sourceType must be one of all, manual, or hubspot.");
+}
+function optionalTrimmed(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizeCreatedAt(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    return optionalTrimmed(value);
+}
+function compactDncListEntry(entry) {
+    const domain = optionalTrimmed(entry.domain);
+    const linkedin = optionalTrimmed(entry.normalizedLinkedinUrl);
+    const sourceType = optionalTrimmed(entry.sourceType) ?? "manual";
+    return {
+        id: optionalTrimmed(entry.id),
+        type: domain ? "domain" : "linkedin",
+        domain,
+        linkedin,
+        linkedinUsername: optionalTrimmed(entry.linkedinUsername),
+        name: optionalTrimmed(entry.name),
+        source: {
+            type: sourceType,
+            label: optionalTrimmed(entry.sourceLabel) ??
+                (sourceType === "hubspot" ? "HubSpot" : "Manual"),
+            listName: optionalTrimmed(entry.sourceListName),
+        },
+        createdAt: normalizeCreatedAt(entry.createdAt),
+    };
+}
+function buildDncListPath(input) {
+    const page = clampListPositiveInt(input.page, 1, Number.MAX_SAFE_INTEGER);
+    const limit = clampListPositiveInt(input.limit, 25, MAX_DNC_LIST_LIMIT);
+    const sourceType = normalizeDncSourceType(input.sourceType);
+    const params = new URLSearchParams({
+        page: String(page),
+        limit: String(limit),
+    });
+    const search = optionalTrimmed(input.search);
+    const listName = optionalTrimmed(input.listName);
+    if (search)
+        params.set("search", search);
+    if (listName)
+        params.set("listName", listName);
+    if (sourceType !== "all")
+        params.set("sourceType", sourceType);
+    if (input.includeDeleted === true)
+        params.set("includeDeleted", "true");
+    return {
+        path: `/api/v3/dnc-list?${params.toString()}`,
+        page,
+        limit,
+    };
+}
 function makeSignature(payload) {
     return createHmac("sha256", confirmationSecret)
         .update(JSON.stringify(payload))
@@ -556,6 +625,29 @@ async function runDncSpotChecks(entries) {
     }
     return checks;
 }
+export async function listDncEntries(input = {}) {
+    const workspace = await getVerifiedActiveWorkspace();
+    const api = getApi();
+    const request = buildDncListPath(input);
+    const response = await api.get(request.path);
+    const pagination = response.pagination ?? {};
+    return {
+        ok: true,
+        workspaceId: workspace.id,
+        workspaceName: workspace.name,
+        pagination: {
+            total: pagination.total ?? 0,
+            page: pagination.page ?? request.page,
+            limit: pagination.limit ?? request.limit,
+            totalPages: pagination.totalPages ?? 0,
+        },
+        listNames: Array.isArray(response.listNames) ? response.listNames : [],
+        entries: Array.isArray(response.entries)
+            ? response.entries.map(compactDncListEntry)
+            : [],
+        guidance: "This is Sellable's workspace DNC list used by DNC Check.",
+    };
+}
 export async function loadCsvDncEntries(input) {
     const workspace = await getVerifiedActiveWorkspace();
     const api = getApi();

package/dist/tools/engage-discovery.d.ts

@@ -1,3 +1,14 @@
+type FollowerBandFit = "in_target_band" | "below_target_band" | "above_target_band" | "unknown";
+type ReachSignals = {
+    targetFollowerMin?: number;
+    targetFollowerMax?: number;
+    followerBandFit: FollowerBandFit;
+    engagementPer1kFollowers: number | null;
+    weightedEngagementPer1kFollowers: number | null;
+    reachPenaltyMultiplier: number;
+    reachAdjustedScore: number;
+    confidence: "high" | "medium" | "low";
+};
 export type EngagementPost = {
     postId: string;
     url: string;
@@ -7,7 +18,7 @@ export type EngagementPost = {
         name: string;
         headline: string;
         profileUrl: string;
-        followerCount: number | null;
+        followerCount?: number;
     };
     engagement: {
         likes: number;
@@ -15,16 +26,7 @@ export type EngagementPost = {
         shares: number;
         total: number;
     };
-    reachSignals: {
-        targetFollowerMin: number | null;
-        targetFollowerMax: number | null;
-        followerBandFit: "in_target_band" | "below_target_band" | "above_target_band" | "unknown";
-        weightedEngagement: number;
-        engagementPer1kFollowers: number | null;
-        weightedEngagementPer1kFollowers: number | null;
-        reachPenaltyMultiplier: number;
-        reachAdjustedScore: number | null;
-    };
+    reachSignals?: ReachSignals;
     contentPreview: string;
 };
 export type SearchEngagementPostsInput = {
@@ -33,9 +35,9 @@ export type SearchEngagementPostsInput = {
     maxAgeDays?: number;
     minTotalEngagement?: number;
     maxPosts?: number;
+    excludePostUrls?: string[];
     targetFollowerMin?: number;
     targetFollowerMax?: number;
-    excludePostUrls?: string[];
 };
 export type SearchEngagementPostsResponse = {
     success: boolean;
@@ -76,19 +78,19 @@ export declare const engageDiscoveryToolDefinitions: {
                 type: string;
                 description: string;
             };
-            targetFollowerMin: {
+            excludePostUrls: {
                 type: string;
+                items: {
+                    type: string;
+                };
                 description: string;
             };
-            targetFollowerMax: {
+            targetFollowerMin: {
                 type: string;
                 description: string;
             };
-            excludePostUrls: {
+            targetFollowerMax: {
                 type: string;
-                items: {
-                    type: string;
-                };
                 description: string;
             };
         };
@@ -97,3 +99,4 @@ export declare const engageDiscoveryToolDefinitions: {
     };
 }[];
 export declare function searchEngagementPosts(input: SearchEngagementPostsInput): Promise<SearchEngagementPostsResponse>;
+export {};

package/dist/tools/engage-discovery.js

@@ -27,18 +27,18 @@ export const engageDiscoveryToolDefinitions = [
                     type: "number",
                     description: "Max posts to return after filtering (default 25).",
                 },
+                excludePostUrls: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional list of post URLs to exclude (e.g. already engaged/scheduled).",
+                },
                 targetFollowerMin: {
                     type: "number",
-                    description: "Optional lower bound for the author's follower count when comparing reach-normalized hook performance. Does not hard-filter; adds reach signals and prioritizes the target band when follower data is available.",
+                    description: "Optional lower bound for creator follower count when reach-normalizing hook/source quality.",
                 },
                 targetFollowerMax: {
                     type: "number",
-                    description: "Optional upper bound for the author's follower count when comparing reach-normalized hook performance. Does not hard-filter; adds reach signals and prioritizes the target band when follower data is available.",
-                },
-                excludePostUrls: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Optional list of post URLs to exclude (e.g. already engaged/scheduled).",
+                    description: "Optional upper bound for creator follower count when reach-normalizing hook/source quality.",
                 },
             },
             required: ["keywords"],
@@ -71,99 +71,77 @@ function safeNumber(value) {
     const n = typeof value === "number" ? value : Number(value);
     return Number.isFinite(n) ? n : 0;
 }
-function parseFollowerCount(value) {
-    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
-        return Math.round(value);
-    }
-    if (typeof value !== "string")
-        return null;
-    const cleaned = value.trim().toLowerCase().replace(/,/g, "");
-    if (!cleaned)
-        return null;
-    const match = cleaned.match(/(\d+(?:\.\d+)?)\s*([kmb])?/);
+function round3(value) {
+    return Number(value.toFixed(3));
+}
+function parseFollowerCount(author) {
+    const direct = safeNumber(author?.followerCount);
+    if (direct > 0)
+        return direct;
+    const text = String(author?.followers || author?.followerCountText || "");
+    const match = text.match(/([\d,.]+)\s*([kKmM])?/);
     if (!match)
-        return null;
-    const base = Number(match[1]);
+        return undefined;
+    const base = Number(match[1].replace(/,/g, ""));
     if (!Number.isFinite(base) || base <= 0)
-        return null;
-    const suffix = match[2] || "";
-    const multiplier = suffix === "b" ? 1_000_000_000 : suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
-    return Math.round(base * multiplier);
+        return undefined;
+    const suffix = match[2]?.toLowerCase();
+    if (suffix === "m")
+        return Math.round(base * 1_000_000);
+    if (suffix === "k")
+        return Math.round(base * 1_000);
+    return Math.round(base);
 }
-function extractFollowerCount(post) {
-    const candidates = [
-        post?.author?.followerCount,
-        post?.author?.followersCount,
-        post?.author?.followers,
-        post?.author?.follower_count,
-        post?.author?.linkedinFollowers,
-        post?.author?.stats?.followers,
-        post?.followerCount,
-        post?.followersCount,
-        post?.followers,
-        post?.authorFollowerCount,
-    ];
-    for (const candidate of candidates) {
-        const parsed = parseFollowerCount(candidate);
-        if (parsed !== null)
-            return parsed;
-    }
-    return null;
-}
-function normalizeFollowerBound(value) {
-    const parsed = parseFollowerCount(value);
-    return parsed && parsed > 0 ? parsed : null;
-}
-function followerBandFit(followerCount, targetFollowerMin, targetFollowerMax) {
-    if (!followerCount)
-        return "unknown";
-    if (targetFollowerMin && followerCount < targetFollowerMin) {
-        return "below_target_band";
-    }
-    if (targetFollowerMax && followerCount > targetFollowerMax) {
-        return "above_target_band";
-    }
-    if (targetFollowerMin || targetFollowerMax)
-        return "in_target_band";
-    return "unknown";
-}
-function bandMultiplier(fit, followerCount, targetFollowerMax) {
-    if (fit === "in_target_band")
+function reachPenaltyMultiplier(followerCount, targetFollowerMin, targetFollowerMax) {
+    if (!followerCount || !targetFollowerMin || !targetFollowerMax)
+        return 0.4;
+    if (followerCount >= targetFollowerMin && followerCount <= targetFollowerMax) {
         return 1;
-    if (fit === "below_target_band")
+    }
+    if (followerCount < targetFollowerMin)
         return 0.75;
-    if (fit === "unknown")
-        return 0.4;
-    if (!followerCount || !targetFollowerMax)
-        return 0.45;
     if (followerCount <= targetFollowerMax * 2)
         return 0.65;
     if (followerCount <= targetFollowerMax * 5)
         return 0.35;
     return 0.15;
 }
-function reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax) {
-    const weightedEngagement = engagement.likes + engagement.comments * 4 + engagement.shares * 12;
-    const fit = followerBandFit(followerCount, targetFollowerMin, targetFollowerMax);
+function followerBandFit(followerCount, targetFollowerMin, targetFollowerMax) {
+    if (!followerCount || !targetFollowerMin || !targetFollowerMax) {
+        return "unknown";
+    }
+    if (followerCount >= targetFollowerMin && followerCount <= targetFollowerMax) {
+        return "in_target_band";
+    }
+    if (followerCount < targetFollowerMin)
+        return "below_target_band";
+    return "above_target_band";
+}
+function buildReachSignals(params) {
+    const { followerCount, likes, comments, shares, total } = params;
+    const hasTarget = Boolean(params.targetFollowerMin && params.targetFollowerMax);
+    if (!hasTarget && !followerCount)
+        return undefined;
+    const weightedEngagement = likes + comments * 4 + shares * 12;
+    const penalty = reachPenaltyMultiplier(followerCount, params.targetFollowerMin, params.targetFollowerMax);
     const engagementPer1kFollowers = followerCount
-        ? Number(((engagement.total / followerCount) * 1000).toFixed(3))
+        ? round3((total / followerCount) * 1000)
         : null;
     const weightedEngagementPer1kFollowers = followerCount
-        ? Number(((weightedEngagement / followerCount) * 1000).toFixed(3))
+        ? round3((weightedEngagement / followerCount) * 1000)
         : null;
-    const reachPenaltyMultiplier = bandMultiplier(fit, followerCount, targetFollowerMax);
     const reachAdjustedScore = weightedEngagementPer1kFollowers === null
-        ? null
-        : Number((weightedEngagementPer1kFollowers * reachPenaltyMultiplier).toFixed(3));
+        ? 0
+        : round3(weightedEngagementPer1kFollowers * penalty);
     return {
-        targetFollowerMin,
-        targetFollowerMax,
-        followerBandFit: fit,
-        weightedEngagement,
+        targetFollowerMin: params.targetFollowerMin,
+        targetFollowerMax: params.targetFollowerMax,
+        followerBandFit: followerBandFit(followerCount, params.targetFollowerMin, params.targetFollowerMax),
         engagementPer1kFollowers,
         weightedEngagementPer1kFollowers,
-        reachPenaltyMultiplier,
+        reachPenaltyMultiplier: penalty,
         reachAdjustedScore,
+        confidence: followerCount ? (hasTarget ? "high" : "medium") : "low",
     };
 }
 export async function searchEngagementPosts(input) {
@@ -182,10 +160,12 @@ export async function searchEngagementPosts(input) {
     const maxPosts = typeof input.maxPosts === "number" && input.maxPosts > 0
         ? Math.min(50, input.maxPosts)
         : 25;
-    const targetFollowerMin = normalizeFollowerBound(input.targetFollowerMin);
-    const targetFollowerMax = normalizeFollowerBound(input.targetFollowerMax);
-    const useTargetFollowerBand = Boolean(targetFollowerMin || targetFollowerMax);
-    const collectLimit = useTargetFollowerBand ? 50 : maxPosts;
+    const targetFollowerMin = typeof input.targetFollowerMin === "number" && input.targetFollowerMin > 0
+        ? input.targetFollowerMin
+        : undefined;
+    const targetFollowerMax = typeof input.targetFollowerMax === "number" && input.targetFollowerMax > 0
+        ? input.targetFollowerMax
+        : undefined;
     const exclude = new Set((input.excludePostUrls || [])
         .map((u) => normalizePostUrl(u))
         .filter(Boolean));
@@ -194,13 +174,11 @@ export async function searchEngagementPosts(input) {
         keywords: keywords.map((keyword) => ({ keyword })),
         page,
     });
-    const rawPosts = useTargetFollowerBand && Array.isArray(response?.posts)
+    const rawPosts = Array.isArray(response?.posts)
         ? response.posts
         : Array.isArray(response?.topPostsForLLM)
             ? response.topPostsForLLM
-            : Array.isArray(response?.posts)
-                ? response.posts
-                : [];
+            : [];
     const now = Date.now();
     const oldestMs = now - maxAgeDays * 24 * 60 * 60 * 1000;
     let tooOld = 0;
@@ -220,7 +198,6 @@ export async function searchEngagementPosts(input) {
         const comments = safeNumber(p?.engagement?.comments);
         const shares = safeNumber(p?.engagement?.shares);
         const total = likes + comments + shares;
-        const engagement = { likes, comments, shares, total };
         if (total < minTotalEngagement) {
             tooLowEngagement += 1;
             continue;
@@ -231,7 +208,16 @@ export async function searchEngagementPosts(input) {
             tooOld += 1;
             continue;
         }
-        const followerCount = extractFollowerCount(p);
+        const followerCount = parseFollowerCount(p?.author);
+        const reachSignals = buildReachSignals({
+            followerCount,
+            likes,
+            comments,
+            shares,
+            total,
+            targetFollowerMin,
+            targetFollowerMax,
+        });
         kept.push({
             postId: String(p?.id || ""),
             url,
@@ -243,34 +229,26 @@ export async function searchEngagementPosts(input) {
                 name: String(p?.author?.name || ""),
                 headline: String(p?.author?.headline || ""),
                 profileUrl: String(p?.author?.profileUrl || ""),
-                followerCount,
+                ...(followerCount ? { followerCount } : {}),
             },
-            engagement,
-            reachSignals: reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax),
+            engagement: { likes, comments, shares, total },
+            ...(reachSignals ? { reachSignals } : {}),
             contentPreview: previewText(String(p?.content || ""), 220),
         });
-        if (kept.length >= collectLimit)
-            break;
-    }
-    if (useTargetFollowerBand) {
-        kept.sort((a, b) => {
-            const scoreDelta = (b.reachSignals.reachAdjustedScore ?? -1) -
-                (a.reachSignals.reachAdjustedScore ?? -1);
-            if (scoreDelta !== 0)
-                return scoreDelta;
-            return b.engagement.total - a.engagement.total;
-        });
-    }
-    else {
-        // Sort by total engagement desc for a predictable shortlist.
-        kept.sort((a, b) => b.engagement.total - a.engagement.total);
-    }
-    if (kept.length > maxPosts) {
-        kept.length = maxPosts;
     }
+    const hasReachTarget = Boolean(targetFollowerMin && targetFollowerMax);
+    kept.sort((a, b) => {
+        if (hasReachTarget) {
+            const reachDelta = (b.reachSignals?.reachAdjustedScore || 0) -
+                (a.reachSignals?.reachAdjustedScore || 0);
+            if (reachDelta !== 0)
+                return reachDelta;
+        }
+        return b.engagement.total - a.engagement.total;
+    });
     return {
         success: true,
-        posts: kept,
+        posts: kept.slice(0, maxPosts),
         totalReturned: rawPosts.length,
         filteredOut: { tooOld, excluded, tooLowEngagement },
     };