@sellable/mcp 0.1.0

package/dist/tools/engage-bootstrap.js

@@ -0,0 +1,205 @@
+import { getEngageState, updateEngageState } from "../auth.js";
+import { senderHasConfig } from "../engage-memory.js";
+import { getAuthStatus } from "./auth.js";
+import { getEngagedPosts, getOrCreateDirectCampaignTable, } from "./direct-campaigns.js";
+import { listSenders } from "./senders.js";
+// ── Tool definitions ──────────────────────────────────────────────────────
+export const engageBootstrapToolDefinitions = [
+    {
+        name: "bootstrap_engage",
+        description: "Engage preflight: verify auth/workspace, resolve sender (workspace-first), ensure comment campaign table exists, fetch engaged posts for dedupe, and persist defaults. Minimizes back-and-forth before discovery. IMPORTANT: After auth succeeds, ALWAYS tell the user which workspace is active (from authStatus._userNotice).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                senderId: {
+                    type: "string",
+                    description: "Optional senderId override. If omitted, uses lastSenderId for the active workspace when available, otherwise auto-selects only sender or requests a choice.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "bootstrap_engage_multi",
+        description: "Multi-sender engage preflight: resolve multiple senders in parallel, ensure each has a comment campaign table, fetch engaged posts for all, and return a globalEngagedPostUrls union for cross-sender dedup. Use for multi-sender engage sessions (autonomous or interactive).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                senderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Specific sender IDs to bootstrap. Mutually exclusive with allSenders.",
+                },
+                allSenders: {
+                    type: "boolean",
+                    description: "If true, bootstrap ALL senders in the workspace. Mutually exclusive with senderIds.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+function senderSummary(s) {
+    return {
+        id: String(s?.id || ""),
+        displayName: String(s?.displayName || s?.id || ""),
+        linkedinProfileUrl: s?.linkedinProfileUrl ?? null,
+    };
+}
+export async function bootstrapEngage(input = {}) {
+    const authStatus = await getAuthStatus();
+    if (!authStatus.ok) {
+        return { ok: false, authStatus };
+    }
+    const engageState = getEngageState();
+    const senderList = await listSenders();
+    const senders = (senderList.senders || []).map(senderSummary);
+    if (senders.length === 0) {
+        return {
+            ok: true,
+            authStatus,
+            needsUserChoice: true,
+            reason: "no_senders",
+            senders,
+            addSenderPath: "/outbound/senders",
+        };
+    }
+    const overrideSenderId = input.senderId?.trim() || null;
+    const preferredSenderId = overrideSenderId || engageState.state?.lastSenderId || null;
+    const preferred = preferredSenderId && senders.find((s) => s.id === preferredSenderId);
+    let selectedSender = preferred || null;
+    if (!selectedSender) {
+        if (overrideSenderId) {
+            return {
+                ok: true,
+                authStatus,
+                needsUserChoice: true,
+                reason: "unknown_sender",
+                senders,
+                addSenderPath: "/outbound/senders",
+            };
+        }
+        if (senders.length === 1) {
+            selectedSender = senders[0] || null;
+        }
+        else {
+            return {
+                ok: true,
+                authStatus,
+                needsUserChoice: true,
+                reason: "multiple_senders",
+                senders,
+                addSenderPath: "/outbound/senders",
+            };
+        }
+    }
+    const table = await getOrCreateDirectCampaignTable({
+        senderId: selectedSender.id,
+        type: "comment_campaign",
+    });
+    const engaged = await getEngagedPosts({ senderId: selectedSender.id });
+    const engagedPostUrls = Array.isArray(engaged?.postUrls)
+        ? engaged.postUrls
+        : [];
+    updateEngageState({
+        lastSenderId: selectedSender.id,
+        lastCommentCampaignTableId: table.tableId,
+    });
+    return {
+        ok: true,
+        authStatus,
+        needsUserChoice: false,
+        selected: {
+            senderId: selectedSender.id,
+            senderDisplayName: selectedSender.displayName,
+            senderLinkedinProfileUrl: selectedSender.linkedinProfileUrl,
+            commentCampaignTableId: table.tableId,
+            tableCreated: Boolean(table.created),
+            engagedPostUrls,
+        },
+    };
+}
+export async function bootstrapEngageMulti(input = {}) {
+    const authStatus = await getAuthStatus();
+    if (!authStatus.ok) {
+        return { ok: false, error: "Auth failed. Check token and workspace." };
+    }
+    const senderList = await listSenders();
+    const allSenders = (senderList.senders || []).map(senderSummary);
+    if (allSenders.length === 0) {
+        return {
+            ok: false,
+            error: "No senders in workspace. Add one at https://app.sellable.dev/linkedin-accounts",
+        };
+    }
+    // Determine which senders to bootstrap
+    let targetSenders;
+    if (input.allSenders) {
+        targetSenders = allSenders;
+    }
+    else if (input.senderIds && input.senderIds.length > 0) {
+        targetSenders = [];
+        for (const id of input.senderIds) {
+            const found = allSenders.find((s) => s.id === id);
+            if (!found) {
+                return {
+                    ok: false,
+                    error: `Unknown senderId: ${id}. Available: ${allSenders.map((s) => `${s.displayName} (${s.id})`).join(", ")}`,
+                };
+            }
+            targetSenders.push(found);
+        }
+    }
+    else {
+        // Default: use all senders
+        targetSenders = allSenders;
+    }
+    // Bootstrap each sender in parallel
+    const senderResults = await Promise.all(targetSenders.map(async (sender) => {
+        const [table, engaged] = await Promise.all([
+            getOrCreateDirectCampaignTable({
+                senderId: sender.id,
+                type: "comment_campaign",
+            }),
+            getEngagedPosts({ senderId: sender.id }),
+        ]);
+        const engagedPostUrls = Array.isArray(engaged?.postUrls)
+            ? engaged.postUrls
+            : [];
+        return {
+            senderId: sender.id,
+            senderDisplayName: sender.displayName,
+            senderLinkedinProfileUrl: sender.linkedinProfileUrl,
+            commentCampaignTableId: table.tableId,
+            tableCreated: Boolean(table.created),
+            engagedPostUrls,
+            hasConfig: senderHasConfig(sender.id),
+        };
+    }));
+    // Build global engaged post URLs (union of all senders)
+    const globalSet = new Set();
+    for (const sr of senderResults) {
+        for (const url of sr.engagedPostUrls) {
+            globalSet.add(url);
+        }
+    }
+    // Persist multi-sender state
+    const tableIdMap = {};
+    for (const sr of senderResults) {
+        tableIdMap[sr.senderId] = sr.commentCampaignTableId;
+    }
+    updateEngageState({
+        lastSenderIds: senderResults.map((sr) => sr.senderId),
+        lastCommentCampaignTableIds: tableIdMap,
+        // Also set lastSenderId to first sender for backward compat
+        lastSenderId: senderResults[0]?.senderId,
+        lastCommentCampaignTableId: senderResults[0]?.commentCampaignTableId,
+    });
+    return {
+        ok: true,
+        senders: senderResults,
+        globalEngagedPostUrls: Array.from(globalSet),
+    };
+}

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

@@ -0,0 +1,78 @@
+export type EngagementPost = {
+    postId: string;
+    url: string;
+    postedAt: string | null;
+    matchedKeyword: string | null;
+    author: {
+        name: string;
+        headline: string;
+        profileUrl: string;
+    };
+    engagement: {
+        likes: number;
+        comments: number;
+        shares: number;
+        total: number;
+    };
+    contentPreview: string;
+};
+export type SearchEngagementPostsInput = {
+    keywords: string[];
+    page?: number;
+    maxAgeDays?: number;
+    minTotalEngagement?: number;
+    maxPosts?: number;
+    excludePostUrls?: string[];
+};
+export type SearchEngagementPostsResponse = {
+    success: boolean;
+    posts: EngagementPost[];
+    totalReturned: number;
+    filteredOut: {
+        tooOld: number;
+        excluded: number;
+        tooLowEngagement: number;
+    };
+};
+export declare const engageDiscoveryToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            keywords: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            page: {
+                type: string;
+                description: string;
+            };
+            maxAgeDays: {
+                type: string;
+                description: string;
+            };
+            minTotalEngagement: {
+                type: string;
+                description: string;
+            };
+            maxPosts: {
+                type: string;
+                description: string;
+            };
+            excludePostUrls: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function searchEngagementPosts(input: SearchEngagementPostsInput): Promise<SearchEngagementPostsResponse>;

package/dist/tools/engage-discovery.js

@@ -0,0 +1,150 @@
+import { getApi } from "../api.js";
+export const engageDiscoveryToolDefinitions = [
+    {
+        name: "search_engagement_posts",
+        description: "Search for high-signal LinkedIn posts by keyword for engagement/comment drafting. Designed for the engage skill (no campaignOfferId required). Filters by recency and engagement, and can exclude already-engaged URLs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                keywords: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Search keywords (max 5 recommended).",
+                },
+                page: {
+                    type: "number",
+                    description: "Page number (default 1).",
+                },
+                maxAgeDays: {
+                    type: "number",
+                    description: "Max post age in days (default 5).",
+                },
+                minTotalEngagement: {
+                    type: "number",
+                    description: "Minimum total engagement (likes+comments+shares) to keep (default 30).",
+                },
+                maxPosts: {
+                    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).",
+                },
+            },
+            required: ["keywords"],
+            additionalProperties: false,
+        },
+    },
+];
+function normalizePostUrl(url) {
+    if (!url)
+        return null;
+    try {
+        const parsed = new URL(url);
+        parsed.hash = "";
+        parsed.search = "";
+        return `${parsed.origin}${parsed.pathname}`.toLowerCase();
+    }
+    catch {
+        return url.trim().toLowerCase();
+    }
+}
+function previewText(text, max) {
+    const cleaned = String(text || "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (cleaned.length <= max)
+        return cleaned;
+    return `${cleaned.slice(0, max - 1)}…`;
+}
+function safeNumber(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) ? n : 0;
+}
+export async function searchEngagementPosts(input) {
+    const api = getApi();
+    const keywords = (input.keywords || [])
+        .map((k) => String(k || "").trim())
+        .filter(Boolean)
+        .slice(0, 5);
+    const page = input.page && input.page > 0 ? input.page : 1;
+    const maxAgeDays = typeof input.maxAgeDays === "number" && input.maxAgeDays > 0
+        ? input.maxAgeDays
+        : 5;
+    const minTotalEngagement = typeof input.minTotalEngagement === "number"
+        ? input.minTotalEngagement
+        : 30;
+    const maxPosts = typeof input.maxPosts === "number" && input.maxPosts > 0
+        ? Math.min(50, input.maxPosts)
+        : 25;
+    const exclude = new Set((input.excludePostUrls || [])
+        .map((u) => normalizePostUrl(u))
+        .filter(Boolean));
+    const response = await api.post("/api/v1/signal-discovery/search-signals", {
+        type: "keywords",
+        keywords: keywords.map((keyword) => ({ keyword })),
+        page,
+    });
+    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;
+    let excluded = 0;
+    let tooLowEngagement = 0;
+    const kept = [];
+    for (const p of rawPosts) {
+        const url = String(p?.url || "").trim();
+        if (!url)
+            continue;
+        const norm = normalizePostUrl(url);
+        if (norm && exclude.has(norm)) {
+            excluded += 1;
+            continue;
+        }
+        const likes = safeNumber(p?.engagement?.likes);
+        const comments = safeNumber(p?.engagement?.comments);
+        const shares = safeNumber(p?.engagement?.shares);
+        const total = likes + comments + shares;
+        if (total < minTotalEngagement) {
+            tooLowEngagement += 1;
+            continue;
+        }
+        const postedAtRaw = p?.postedAt ? String(p.postedAt) : "";
+        const postedMs = postedAtRaw ? Date.parse(postedAtRaw) : NaN;
+        if (Number.isFinite(postedMs) && postedMs < oldestMs) {
+            tooOld += 1;
+            continue;
+        }
+        kept.push({
+            postId: String(p?.id || ""),
+            url,
+            postedAt: Number.isFinite(postedMs)
+                ? new Date(postedMs).toISOString()
+                : null,
+            matchedKeyword: p?.matchedKeyword ? String(p.matchedKeyword) : null,
+            author: {
+                name: String(p?.author?.name || ""),
+                headline: String(p?.author?.headline || ""),
+                profileUrl: String(p?.author?.profileUrl || ""),
+            },
+            engagement: { likes, comments, shares, total },
+            contentPreview: previewText(String(p?.content || ""), 220),
+        });
+        if (kept.length >= maxPosts)
+            break;
+    }
+    // Sort by total engagement desc for a predictable shortlist.
+    kept.sort((a, b) => b.engagement.total - a.engagement.total);
+    return {
+        success: true,
+        posts: kept,
+        totalReturned: rawPosts.length,
+        filteredOut: { tooOld, excluded, tooLowEngagement },
+    };
+}

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

@@ -0,0 +1,181 @@
+export declare const engageMemoryToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            markdown: {
+                type: string;
+                description: string;
+            };
+            senderId: {
+                type: string;
+                description: string;
+            };
+            keyword?: undefined;
+            totalReturned?: undefined;
+            postsYielded?: undefined;
+            name?: undefined;
+            linkedinUrl?: undefined;
+            reason?: undefined;
+            fromSenderId?: undefined;
+            toSenderId?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            keyword: {
+                type: string;
+                description: string;
+            };
+            totalReturned: {
+                type: string;
+                description: string;
+            };
+            postsYielded: {
+                type: string;
+                description: string;
+            };
+            senderId: {
+                type: string;
+                description: string;
+            };
+            markdown?: undefined;
+            name?: undefined;
+            linkedinUrl?: undefined;
+            reason?: undefined;
+            fromSenderId?: undefined;
+            toSenderId?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            linkedinUrl: {
+                type: string;
+                description: string;
+            };
+            reason: {
+                type: string;
+                description: string;
+            };
+            senderId: {
+                type: string;
+                description: string;
+            };
+            markdown?: undefined;
+            keyword?: undefined;
+            totalReturned?: undefined;
+            postsYielded?: undefined;
+            fromSenderId?: undefined;
+            toSenderId?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            fromSenderId: {
+                type: string;
+                description: string;
+            };
+            toSenderId: {
+                type: string;
+                description: string;
+            };
+            markdown?: undefined;
+            senderId?: undefined;
+            keyword?: undefined;
+            totalReturned?: undefined;
+            postsYielded?: undefined;
+            name?: undefined;
+            linkedinUrl?: undefined;
+            reason?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            senderId: {
+                type: string;
+                description: string;
+            };
+            markdown?: undefined;
+            keyword?: undefined;
+            totalReturned?: undefined;
+            postsYielded?: undefined;
+            name?: undefined;
+            linkedinUrl?: undefined;
+            reason?: undefined;
+            fromSenderId?: undefined;
+            toSenderId?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function getEngageMemoryTool(input?: {
+    senderId?: string;
+}): {
+    memory: import("../engage-memory.js").EngageMemory;
+};
+export declare function setEngageStyleGuideTool(input: {
+    markdown: string;
+    senderId?: string;
+}): {
+    styleGuide: import("../engage-memory.js").EngageStyleGuide;
+};
+export declare function recordEngageProvenSearchTool(input: {
+    keyword: string;
+    totalReturned: number;
+    postsYielded: number;
+    senderId?: string;
+}): {
+    search: import("../engage-memory.js").ProvenSearch;
+};
+export declare function upsertEngageTrackedPersonTool(input: {
+    name: string;
+    linkedinUrl: string;
+    reason: string;
+    senderId?: string;
+}): {
+    person: import("../engage-memory.js").TrackedPerson;
+    created: boolean;
+};
+export declare function copySenderConfigTool(input: {
+    fromSenderId: string;
+    toSenderId: string;
+}): {
+    copied: string[];
+    skipped: string[];
+};
+export declare function migrateFlatConfigsTool(input: {
+    senderId: string;
+}): {
+    migrated: string[];
+    skipped: string[];
+};