@sellable/mcp 0.1.235 → 0.1.237

package/dist/tools/content-posts.js

@@ -0,0 +1,611 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const CONTENT_ROOT_ENV = "SELLABLE_CONTENT_DIR";
+const DEFAULT_PREVIEW_CHARS = 220;
+const RELATIVE_DIRS = {
+    ideas: "linkedin/ideas",
+    hookResearch: "linkedin/research/hooks",
+    drafts: "linkedin/drafts",
+    published: "linkedin/published",
+    commentLibrary: "linkedin/comments/library",
+};
+export const contentPostToolDefinitions = [
+    {
+        name: "capture_post_idea",
+        description: "Capture a raw LinkedIn post idea into ~/.sellable/content/linkedin/ideas. Preserves the raw source exactly and returns an ID for later drafting.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                rawSource: {
+                    type: "string",
+                    description: "The user's original idea, transcript, or freestyle note. This is preserved exactly.",
+                },
+                title: { type: "string" },
+                distilledBrief: {
+                    type: "string",
+                    description: "Optional short brief. Must not add claims beyond rawSource.",
+                },
+                ideaId: {
+                    type: "string",
+                    description: "Optional stable ID. Must be a safe filename without slashes.",
+                },
+                sourceType: { type: "string" },
+                sourceUrl: { type: "string" },
+                capturedAt: { type: "string" },
+            },
+            required: ["rawSource"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "list_post_ideas",
+        description: "List captured LinkedIn post ideas with compact sanitized previews. Use get_post_idea for full Markdown.",
+        inputSchema: listInputSchema(),
+    },
+    {
+        name: "get_post_idea",
+        description: "Read one captured LinkedIn post idea by ID, including its full Markdown and exact raw source section.",
+        inputSchema: idInputSchema("ideaId"),
+    },
+    {
+        name: "save_hook_research",
+        description: "Save hook research for a LinkedIn post idea under ~/.sellable/content/linkedin/research/hooks.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                researchId: { type: "string" },
+                ideaId: { type: "string" },
+                topic: { type: "string" },
+                keywords: { type: "array", items: { type: "string" } },
+                sourcePosts: {
+                    type: "array",
+                    items: { type: "object", additionalProperties: true },
+                },
+                selectedPatterns: {
+                    type: "array",
+                    items: { type: "string" },
+                },
+                notes: { type: "string" },
+                createdAt: { type: "string" },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "save_post_draft",
+        description: "Save a validated LinkedIn post draft under ~/.sellable/content/linkedin/drafts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                draftId: { type: "string" },
+                ideaId: { type: "string" },
+                hookResearchId: { type: "string" },
+                title: { type: "string" },
+                body: { type: "string" },
+                validationReceipt: {
+                    description: "Markdown string or structured object with hook, proof, voice, anti-AI, concrete-language, finalizer, and blocked/retry checks.",
+                },
+                createdAt: { type: "string" },
+                status: { type: "string" },
+            },
+            required: ["ideaId", "body", "validationReceipt"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "list_post_drafts",
+        description: "List saved LinkedIn post drafts with compact sanitized previews. Use get_post_draft for full Markdown.",
+        inputSchema: listInputSchema(),
+    },
+    {
+        name: "get_post_draft",
+        description: "Read one saved LinkedIn post draft by ID.",
+        inputSchema: idInputSchema("draftId"),
+    },
+    {
+        name: "mark_post_published",
+        description: "Record a published LinkedIn post under ~/.sellable/content/linkedin/published/{year}. Drafts and published posts remain separate files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                draftId: { type: "string" },
+                publishUrl: { type: "string" },
+                activityId: { type: "string" },
+                publishedAt: { type: "string" },
+                finalText: { type: "string" },
+                title: { type: "string" },
+            },
+            required: ["publishUrl"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "list_published_posts",
+        description: "List published LinkedIn post records with compact sanitized previews.",
+        inputSchema: listInputSchema(),
+    },
+];
+function listInputSchema() {
+    return {
+        type: "object",
+        properties: {
+            limit: { type: "number" },
+        },
+        required: [],
+        additionalProperties: false,
+    };
+}
+function idInputSchema(propertyName) {
+    return {
+        type: "object",
+        properties: {
+            [propertyName]: { type: "string" },
+        },
+        required: [propertyName],
+        additionalProperties: false,
+    };
+}
+export function resolveContentRoot() {
+    const envValue = process.env[CONTENT_ROOT_ENV]?.trim();
+    if (envValue) {
+        return normalizeConfiguredRoot(envValue, CONTENT_ROOT_ENV);
+    }
+    const home = os.homedir();
+    if (!home || !path.isAbsolute(home)) {
+        throw new Error(`Unable to resolve Sellable content root: ${CONTENT_ROOT_ENV} is unset and home directory is unavailable.`);
+    }
+    return path.resolve(home, ".sellable/content");
+}
+function normalizeConfiguredRoot(value, label) {
+    const expanded = expandLeadingTilde(value);
+    if (!path.isAbsolute(expanded)) {
+        throw new Error(`${label} must be an absolute path.`);
+    }
+    return path.resolve(expanded);
+}
+function expandLeadingTilde(value) {
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return path.join(os.homedir(), value.slice(2));
+    }
+    return value;
+}
+export function ensureContentLayout(root = resolveContentRoot()) {
+    for (const relativeDir of Object.values(RELATIVE_DIRS)) {
+        fs.mkdirSync(safePath(root, relativeDir), { recursive: true });
+    }
+    return {
+        root,
+        directories: { ...RELATIVE_DIRS },
+    };
+}
+export function capturePostIdeaTool(input) {
+    requireString(input.rawSource, "rawSource");
+    const now = normalizeDate(input.capturedAt);
+    const id = input.ideaId ??
+        `idea_${dateStamp(now)}_${slugify(input.title || input.rawSource)}`;
+    const safeId = normalizeArtifactId(id, "ideaId");
+    const metadata = {
+        id: safeId,
+        type: "idea",
+        status: "captured",
+        title: input.title,
+        sourceType: input.sourceType,
+        sourceUrl: input.sourceUrl,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const relativePath = `${RELATIVE_DIRS.ideas}/${safeId}.md`;
+    const markdown = buildMarkdown(metadata, [
+        ["Distilled Brief", input.distilledBrief || ""],
+        ["Raw Source", rawBlock(input.rawSource)],
+        ["Source Metadata", jsonBlock(stripUndefined({
+                sourceType: input.sourceType,
+                sourceUrl: input.sourceUrl,
+                capturedAt: now,
+            }))],
+    ]);
+    writeArtifact(relativePath, markdown);
+    return {
+        id: safeId,
+        path: relativePath,
+        status: metadata.status,
+        createdAt: now,
+        updatedAt: now,
+        preview: sanitizedPreview(input.rawSource),
+        rawSourceExact: true,
+    };
+}
+export function listPostIdeasTool(input) {
+    return listArtifacts(RELATIVE_DIRS.ideas, "idea", input?.limit);
+}
+export function getPostIdeaTool(input) {
+    return getArtifact(RELATIVE_DIRS.ideas, input.ideaId, "ideaId");
+}
+export function saveHookResearchTool(input) {
+    const now = normalizeDate(input.createdAt);
+    const id = input.researchId ??
+        `research_${dateStamp(now)}_${slugify(input.topic || input.ideaId || "hooks")}`;
+    const safeId = normalizeArtifactId(id, "researchId");
+    const safeIdeaId = input.ideaId
+        ? normalizeArtifactId(input.ideaId, "ideaId")
+        : undefined;
+    const metadata = {
+        id: safeId,
+        type: "hook_research",
+        status: "researched",
+        title: input.topic,
+        ideaId: safeIdeaId,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const relativePath = `${RELATIVE_DIRS.hookResearch}/${safeId}.md`;
+    const markdown = buildMarkdown(metadata, [
+        ["Keywords", listBlock(input.keywords ?? [])],
+        ["Selected Patterns", listBlock(input.selectedPatterns ?? [])],
+        ["Source Posts", jsonBlock(input.sourcePosts ?? [])],
+        ["Notes", input.notes || ""],
+    ]);
+    writeArtifact(relativePath, markdown);
+    return {
+        id: safeId,
+        path: relativePath,
+        status: metadata.status,
+        ideaId: safeIdeaId,
+        updatedAt: now,
+        preview: sanitizedPreview(input.notes || input.topic || ""),
+    };
+}
+export function savePostDraftTool(input) {
+    const now = normalizeDate(input.createdAt);
+    const safeIdeaId = normalizeArtifactId(input.ideaId, "ideaId");
+    const safeResearchId = input.hookResearchId
+        ? normalizeArtifactId(input.hookResearchId, "hookResearchId")
+        : undefined;
+    requireString(input.body, "body");
+    const id = input.draftId ??
+        `draft_${dateStamp(now)}_${slugify(input.title || safeIdeaId)}_v1`;
+    const safeId = normalizeArtifactId(id, "draftId");
+    const status = input.status || "draft";
+    if (!["draft", "ready", "needs_revision"].includes(status)) {
+        throw new Error(`Unsupported draft status: ${status}`);
+    }
+    const metadata = {
+        id: safeId,
+        type: "draft",
+        status,
+        title: input.title,
+        ideaId: safeIdeaId,
+        hookResearchId: safeResearchId,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const relativePath = `${RELATIVE_DIRS.drafts}/${safeId}.md`;
+    const markdown = buildMarkdown(metadata, [
+        ["Draft Body", input.body],
+        ["Validation Receipt", formatReceipt(input.validationReceipt)],
+    ]);
+    writeArtifact(relativePath, markdown);
+    return {
+        id: safeId,
+        path: relativePath,
+        status,
+        ideaId: safeIdeaId,
+        hookResearchId: safeResearchId,
+        updatedAt: now,
+        preview: sanitizedPreview(input.body),
+    };
+}
+export function listPostDraftsTool(input) {
+    return listArtifacts(RELATIVE_DIRS.drafts, "draft", input?.limit);
+}
+export function getPostDraftTool(input) {
+    return getArtifact(RELATIVE_DIRS.drafts, input.draftId, "draftId");
+}
+export function markPostPublishedTool(input) {
+    requireString(input.publishUrl, "publishUrl");
+    const publishedAt = normalizeDate(input.publishedAt);
+    const activityId = input.activityId || extractLinkedInActivityId(input.publishUrl);
+    const id = `post_${activityId ? normalizeSlug(activityId) : slugify(input.publishUrl)}`;
+    const safeId = normalizeArtifactId(id, "publishedPostId");
+    const safeDraftId = input.draftId
+        ? normalizeArtifactId(input.draftId, "draftId")
+        : undefined;
+    const year = new Date(publishedAt).getUTCFullYear().toString();
+    const relativePath = `${RELATIVE_DIRS.published}/${year}/${safeId}.md`;
+    const existing = readArtifactIfExists(relativePath);
+    const createdAt = existing?.metadata.createdAt || publishedAt;
+    const metadata = {
+        id: safeId,
+        type: "published_post",
+        status: "published",
+        title: input.title || existing?.metadata.title,
+        draftId: safeDraftId,
+        publishUrl: input.publishUrl,
+        activityId: activityId || undefined,
+        publishedAt,
+        createdAt,
+        updatedAt: publishedAt,
+    };
+    const markdown = buildMarkdown(metadata, [
+        ["Final Text", input.finalText || ""],
+        ["Publish Metadata", jsonBlock(stripUndefined({
+                draftId: safeDraftId,
+                publishUrl: input.publishUrl,
+                activityId: activityId || undefined,
+                publishedAt,
+            }))],
+        ["Future Metrics", jsonBlock({
+                impressions: null,
+                reactions: null,
+                comments: null,
+                snapshots: [],
+            })],
+    ]);
+    writeArtifact(relativePath, markdown);
+    return {
+        id: safeId,
+        path: relativePath,
+        status: metadata.status,
+        draftId: safeDraftId,
+        publishUrl: input.publishUrl,
+        publishedAt,
+        updatedAt: publishedAt,
+        preview: sanitizedPreview(input.finalText || input.publishUrl),
+    };
+}
+export function listPublishedPostsTool(input) {
+    const root = resolveContentRoot();
+    ensureContentLayout(root);
+    const publishedRoot = safePath(root, RELATIVE_DIRS.published);
+    if (!fs.existsSync(publishedRoot))
+        return [];
+    const artifacts = [];
+    for (const yearDir of fs.readdirSync(publishedRoot)) {
+        if (!/^\d{4}$/.test(yearDir))
+            continue;
+        const fullYearDir = path.join(publishedRoot, yearDir);
+        if (!fs.statSync(fullYearDir).isDirectory())
+            continue;
+        artifacts.push(...readArtifactsFromDir(`${RELATIVE_DIRS.published}/${yearDir}`));
+    }
+    return summarizeArtifacts(artifacts, input?.limit);
+}
+function getArtifact(relativeDir, id, label) {
+    const safeId = normalizeArtifactId(id, label);
+    const relativePath = `${relativeDir}/${safeId}.md`;
+    const artifact = readArtifactIfExists(relativePath);
+    if (!artifact) {
+        throw new Error(`No ${label} found for ID: ${safeId}`);
+    }
+    return {
+        id: artifact.metadata.id,
+        path: relativePath,
+        metadata: artifact.metadata,
+        markdown: artifact.markdown,
+        rawSource: extractRawSource(artifact.markdown),
+    };
+}
+function listArtifacts(relativeDir, kind, limit) {
+    const artifacts = readArtifactsFromDir(relativeDir).filter((artifact) => artifact.metadata.type === kind);
+    return summarizeArtifacts(artifacts, limit);
+}
+function summarizeArtifacts(artifacts, limit) {
+    const boundedLimit = typeof limit === "number" && Number.isFinite(limit)
+        ? Math.max(0, Math.min(Math.floor(limit), 100))
+        : 25;
+    return artifacts
+        .sort((a, b) => String(b.metadata.updatedAt).localeCompare(String(a.metadata.updatedAt)))
+        .slice(0, boundedLimit)
+        .map((artifact) => ({
+        id: artifact.metadata.id,
+        type: artifact.metadata.type,
+        status: artifact.metadata.status,
+        title: artifact.metadata.title,
+        path: artifact.relativePath,
+        updatedAt: artifact.metadata.updatedAt,
+        preview: sanitizedPreview(previewBasis(artifact.markdown)),
+    }));
+}
+function readArtifactsFromDir(relativeDir) {
+    const root = resolveContentRoot();
+    ensureContentLayout(root);
+    const dir = safePath(root, relativeDir);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((entry) => entry.endsWith(".md"))
+        .map((entry) => `${relativeDir}/${entry}`)
+        .map(readArtifactIfExists)
+        .filter((artifact) => artifact !== null);
+}
+function readArtifactIfExists(relativePath) {
+    const root = resolveContentRoot();
+    const filePath = safePath(root, relativePath);
+    if (!fs.existsSync(filePath))
+        return null;
+    const markdown = fs.readFileSync(filePath, "utf8");
+    return {
+        markdown,
+        metadata: parseMetadata(markdown),
+        relativePath,
+    };
+}
+function writeArtifact(relativePath, markdown) {
+    const root = resolveContentRoot();
+    const filePath = safeWritablePath(root, relativePath);
+    fs.writeFileSync(filePath, markdown);
+}
+function safePath(root, relativePath) {
+    validateRelativePath(relativePath);
+    const fullPath = path.resolve(root, ...relativePath.split("/"));
+    const normalizedRoot = path.resolve(root);
+    if (!isPathInside(fullPath, normalizedRoot)) {
+        throw new Error(`Resolved path escapes content root: ${relativePath}`);
+    }
+    return fullPath;
+}
+function safeWritablePath(root, relativePath) {
+    fs.mkdirSync(root, { recursive: true });
+    const rootReal = fs.realpathSync(root);
+    const fullPath = safePath(rootReal, relativePath);
+    const parent = path.dirname(fullPath);
+    fs.mkdirSync(parent, { recursive: true });
+    const parentReal = fs.realpathSync(parent);
+    if (!isPathInside(parentReal, rootReal)) {
+        throw new Error(`Resolved parent path escapes content root: ${relativePath}`);
+    }
+    if (fs.existsSync(fullPath) && fs.lstatSync(fullPath).isSymbolicLink()) {
+        throw new Error(`Refusing to write through symlink: ${relativePath}`);
+    }
+    return path.join(parentReal, path.basename(fullPath));
+}
+function validateRelativePath(relativePath) {
+    if (!relativePath || path.isAbsolute(relativePath)) {
+        throw new Error(`Invalid relative path: ${relativePath}`);
+    }
+    if (relativePath.includes("\\") || relativePath.includes("\0")) {
+        throw new Error(`Invalid relative path: ${relativePath}`);
+    }
+    const decoded = decodeMaybe(relativePath);
+    if (decoded !== relativePath) {
+        validateRelativePath(decoded);
+    }
+    for (const segment of relativePath.split("/")) {
+        if (!segment || segment === "." || segment === "..") {
+            throw new Error(`Invalid relative path segment: ${relativePath}`);
+        }
+    }
+}
+function isPathInside(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function normalizeArtifactId(id, label) {
+    requireString(id, label);
+    const trimmed = id.trim();
+    const decoded = decodeMaybe(trimmed);
+    if (trimmed !== id ||
+        path.isAbsolute(trimmed) ||
+        trimmed.includes("/") ||
+        trimmed.includes("\\") ||
+        trimmed.includes("\0") ||
+        decoded.includes("/") ||
+        decoded.includes("\\") ||
+        trimmed.includes("..") ||
+        decoded.includes("..") ||
+        !/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+        throw new Error(`${label} must be a safe filename ID.`);
+    }
+    return trimmed;
+}
+function requireString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${label} is required.`);
+    }
+}
+function normalizeDate(value) {
+    if (!value)
+        return new Date().toISOString();
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`Invalid date: ${value}`);
+    }
+    return parsed.toISOString();
+}
+function dateStamp(isoDate) {
+    return isoDate.slice(0, 10).replace(/-/g, "");
+}
+function slugify(value) {
+    return normalizeSlug(value).slice(0, 60) || "post";
+}
+function normalizeSlug(value) {
+    return value
+        .toLowerCase()
+        .replace(/https?:\/\//g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function decodeMaybe(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function buildMarkdown(metadata, sections) {
+    const title = metadata.title || metadata.id;
+    const body = sections
+        .map(([heading, content]) => `## ${heading}\n\n${content}`.trimEnd())
+        .join("\n\n");
+    return [
+        "<!-- sellable:metadata",
+        JSON.stringify(stripUndefined(metadata), null, 2),
+        "-->",
+        "",
+        `# ${title}`,
+        "",
+        body,
+        "",
+    ].join("\n");
+}
+function parseMetadata(markdown) {
+    const match = markdown.match(/^<!-- sellable:metadata\n([\s\S]*?)\n-->/m);
+    if (!match) {
+        throw new Error("Missing Sellable content metadata block.");
+    }
+    return JSON.parse(match[1]);
+}
+function rawBlock(rawSource) {
+    return [
+        "<!-- sellable:raw-source:start -->",
+        rawSource,
+        "<!-- sellable:raw-source:end -->",
+    ].join("\n");
+}
+function extractRawSource(markdown) {
+    const match = markdown.match(/<!-- sellable:raw-source:start -->\n([\s\S]*?)\n<!-- sellable:raw-source:end -->/);
+    return match?.[1];
+}
+function previewBasis(markdown) {
+    return (extractRawSource(markdown) ||
+        markdown.replace(/^<!-- sellable:metadata\n[\s\S]*?\n-->\n*/, ""));
+}
+function jsonBlock(value) {
+    return ["```json", JSON.stringify(value, null, 2), "```"].join("\n");
+}
+function listBlock(values) {
+    if (values.length === 0)
+        return "";
+    return values.map((value) => `- ${value}`).join("\n");
+}
+function formatReceipt(value) {
+    if (typeof value === "string")
+        return value;
+    return jsonBlock(value);
+}
+function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function sanitizedPreview(value) {
+    const redacted = value
+        .replace(/\bsk-[A-Za-z0-9_-]{10,}\b/g, "[redacted]")
+        .replace(/\b(?:api[_-]?key|token|secret|password)\b\s*[:=]\s*\S+/gi, "[redacted]")
+        .replace(/\s+/g, " ")
+        .trim();
+    return redacted.length > DEFAULT_PREVIEW_CHARS
+        ? `${redacted.slice(0, DEFAULT_PREVIEW_CHARS - 3)}...`
+        : redacted;
+}
+function extractLinkedInActivityId(url) {
+    const decoded = decodeMaybe(url);
+    const match = decoded.match(/urn:li:activity:(\d+)/) ||
+        decoded.match(/activity[-_:](\d+)/i) ||
+        decoded.match(/activityId=(\d+)/i);
+    return match?.[1] ?? null;
+}

package/dist/tools/leads.d.ts

@@ -3922,7 +3922,7 @@ export declare function searchSignals(input: SignalSearchInput): Promise<{
         id: string;
         url: string | undefined;
         matchedKeyword: string | null;
-        searchType: "company" | "keyword" | "profile" | "post" | null;
+        searchType: "company" | "post" | "keyword" | "profile" | null;
         displayLabel: string | null;
         authorName: string;
         authorHeadline: string;
@@ -3941,7 +3941,7 @@ export declare function searchSignals(input: SignalSearchInput): Promise<{
     }[];
     keywordResults: {
         keyword: string;
-        searchType: "company" | "keyword" | "profile" | "post";
+        searchType: "company" | "post" | "keyword" | "profile";
         displayLabel: string;
         tabId: string | null;
         postCount: number;