@sellable/mcp 0.1.258 → 0.1.259

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

@@ -7,7 +7,6 @@ export type EngagementPost = {
         name: string;
         headline: string;
         profileUrl: string;
-        followerCount: number | null;
     };
     engagement: {
         likes: number;
@@ -15,16 +14,6 @@ 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;
-    };
     contentPreview: string;
 };
 export type SearchEngagementPostsInput = {
@@ -33,8 +22,6 @@ export type SearchEngagementPostsInput = {
     maxAgeDays?: number;
     minTotalEngagement?: number;
     maxPosts?: number;
-    targetFollowerMin?: number;
-    targetFollowerMax?: number;
     excludePostUrls?: string[];
 };
 export type SearchEngagementPostsResponse = {
@@ -76,14 +63,6 @@ export declare const engageDiscoveryToolDefinitions: {
                 type: string;
                 description: string;
             };
-            targetFollowerMin: {
-                type: string;
-                description: string;
-            };
-            targetFollowerMax: {
-                type: string;
-                description: string;
-            };
             excludePostUrls: {
                 type: string;
                 items: {

package/dist/tools/engage-discovery.js

@@ -27,14 +27,6 @@ export const engageDiscoveryToolDefinitions = [
                     type: "number",
                     description: "Max posts to return after filtering (default 25).",
                 },
-                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.",
-                },
-                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" },
@@ -71,101 +63,6 @@ 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])?/);
-    if (!match)
-        return null;
-    const base = Number(match[1]);
-    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);
-}
-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")
-        return 1;
-    if (fit === "below_target_band")
-        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);
-    const engagementPer1kFollowers = followerCount
-        ? Number(((engagement.total / followerCount) * 1000).toFixed(3))
-        : null;
-    const weightedEngagementPer1kFollowers = followerCount
-        ? Number(((weightedEngagement / followerCount) * 1000).toFixed(3))
-        : null;
-    const reachPenaltyMultiplier = bandMultiplier(fit, followerCount, targetFollowerMax);
-    const reachAdjustedScore = weightedEngagementPer1kFollowers === null
-        ? null
-        : Number((weightedEngagementPer1kFollowers * reachPenaltyMultiplier).toFixed(3));
-    return {
-        targetFollowerMin,
-        targetFollowerMax,
-        followerBandFit: fit,
-        weightedEngagement,
-        engagementPer1kFollowers,
-        weightedEngagementPer1kFollowers,
-        reachPenaltyMultiplier,
-        reachAdjustedScore,
-    };
-}
 export async function searchEngagementPosts(input) {
     const api = getApi();
     const keywords = (input.keywords || [])
@@ -182,10 +79,6 @@ 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 exclude = new Set((input.excludePostUrls || [])
         .map((u) => normalizePostUrl(u))
         .filter(Boolean));
@@ -194,13 +87,11 @@ export async function searchEngagementPosts(input) {
         keywords: keywords.map((keyword) => ({ keyword })),
         page,
     });
-    const rawPosts = useTargetFollowerBand && Array.isArray(response?.posts)
-        ? response.posts
-        : Array.isArray(response?.topPostsForLLM)
-            ? response.topPostsForLLM
-            : Array.isArray(response?.posts)
-                ? response.posts
-                : [];
+    const rawPosts = 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 +111,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 +121,6 @@ export async function searchEngagementPosts(input) {
             tooOld += 1;
             continue;
         }
-        const followerCount = extractFollowerCount(p);
         kept.push({
             postId: String(p?.id || ""),
             url,
@@ -243,31 +132,15 @@ export async function searchEngagementPosts(input) {
                 name: String(p?.author?.name || ""),
                 headline: String(p?.author?.headline || ""),
                 profileUrl: String(p?.author?.profileUrl || ""),
-                followerCount,
             },
-            engagement,
-            reachSignals: reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax),
+            engagement: { likes, comments, shares, total },
             contentPreview: previewText(String(p?.content || ""), 220),
         });
-        if (kept.length >= collectLimit)
+        if (kept.length >= maxPosts)
             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;
-    }
+    // Sort by total engagement desc for a predictable shortlist.
+    kept.sort((a, b) => b.engagement.total - a.engagement.total);
     return {
         success: true,
         posts: kept,