@sellable/mcp 0.1.0

package/dist/tools/csv-domains.js

@@ -0,0 +1,464 @@
+import { parse } from "csv-parse/sync";
+import { createHmac, randomBytes } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
+const entryPath = process.argv[1] ? resolve(process.argv[1]) : process.cwd();
+const entryDir = dirname(entryPath);
+const defaultWorkspaceRoot = resolveWorkspaceRoot(entryDir);
+export const MAX_CSV_DOMAIN_UPLOAD_BYTES = 5 * 1024 * 1024;
+export const MAX_CSV_DOMAIN_UPLOAD_ROWS = 7500;
+export const MAX_CSV_DOMAIN_UPLOAD_UNIQUE_DOMAINS = 1000;
+export const MAX_CSV_DOMAIN_CARRY_COLUMNS = 20;
+const CONFIRMATION_TOKEN_VERSION = "csv-domain-preview-v1";
+const confirmationSecret = randomBytes(32).toString("hex");
+const DOMAIN_REGEX = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i;
+const STRONG_DOMAIN_HEADER_KEYS = new Set([
+    "domain",
+    "website",
+    "companydomain",
+    "companywebsite",
+    "url",
+    "homepage",
+]);
+const CANDIDATE_DOMAIN_HEADER_TOKENS = [
+    "domain",
+    "website",
+    "url",
+    "homepage",
+    "site",
+];
+const CARRYOVER_JUNK_KEYS = new Set([
+    "id",
+    "_id",
+    "rowid",
+    "row_id",
+    "createdat",
+    "updatedat",
+    "timestamp",
+    "time",
+    "date",
+    "created",
+    "updated",
+]);
+const CSV_DOMAIN_LIMITS = {
+    maxBytes: MAX_CSV_DOMAIN_UPLOAD_BYTES,
+    maxRows: MAX_CSV_DOMAIN_UPLOAD_ROWS,
+    maxUniqueDomains: MAX_CSV_DOMAIN_UPLOAD_UNIQUE_DOMAINS,
+    maxCarryColumns: MAX_CSV_DOMAIN_CARRY_COLUMNS,
+};
+function normalizeHeaderKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "");
+}
+function compareStringArrays(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+function getLimits() {
+    return { ...CSV_DOMAIN_LIMITS };
+}
+function resolveCsvDomainPath(filePath, workspaceRoot = defaultWorkspaceRoot) {
+    if (!filePath || typeof filePath !== "string") {
+        throw new Error("load_csv_domains requires a non-empty filePath.");
+    }
+    return isAbsolute(filePath)
+        ? resolve(filePath)
+        : resolve(workspaceRoot, filePath);
+}
+function sanitizeCsvDomainCandidate(value) {
+    let cleaned = String(value ?? "")
+        .trim()
+        .toLowerCase();
+    if (!cleaned) {
+        return { valid: false, reason: "Empty domain value" };
+    }
+    if (cleaned.includes("@")) {
+        return { valid: false, reason: "Email addresses are not allowed" };
+    }
+    if (/^https?:\/\//.test(cleaned)) {
+        try {
+            const parsed = new URL(cleaned);
+            cleaned = parsed.host || cleaned;
+        }
+        catch {
+            cleaned = cleaned.replace(/^https?:\/\//, "");
+        }
+    }
+    cleaned = cleaned.replace(/^www\./, "");
+    cleaned = cleaned.split(/[/?#]/)[0] ?? cleaned;
+    cleaned = cleaned.split(":")[0] ?? cleaned;
+    cleaned = cleaned.replace(/\.$/, "");
+    if (!cleaned) {
+        return { valid: false, reason: "Empty domain value" };
+    }
+    if (cleaned.includes(" ")) {
+        return { valid: false, reason: "Contains spaces" };
+    }
+    if (cleaned === "linkedin.com" ||
+        cleaned.endsWith(".linkedin.com") ||
+        cleaned.includes("linkedin.com/")) {
+        return {
+            valid: false,
+            reason: "LinkedIn URLs are not allowed; use the company website domain",
+        };
+    }
+    if (!cleaned.includes(".")) {
+        return { valid: false, reason: "Missing top-level domain" };
+    }
+    if (!DOMAIN_REGEX.test(cleaned)) {
+        return { valid: false, reason: "Invalid domain format" };
+    }
+    return { valid: true, cleaned };
+}
+function findDuplicateHeaders(headers) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const header of headers) {
+        const normalized = header.trim().toLowerCase();
+        if (!normalized) {
+            continue;
+        }
+        if (seen.has(normalized)) {
+            duplicates.add(header);
+            continue;
+        }
+        seen.add(normalized);
+    }
+    return Array.from(duplicates);
+}
+function buildRowObjects(headers, dataRows) {
+    return dataRows.map((row) => {
+        const out = {};
+        headers.forEach((header, index) => {
+            out[header] = String(row[index] ?? "");
+        });
+        return out;
+    });
+}
+function resolveHeaderSelection(headers, requested, kind) {
+    const trimmed = requested.trim();
+    if (!trimmed) {
+        throw new Error(`${kind} entries must be non-empty strings.`);
+    }
+    const exact = headers.find((header) => header === trimmed);
+    if (exact) {
+        return exact;
+    }
+    const lowered = trimmed.toLowerCase();
+    const matches = headers.filter((header) => header.trim().toLowerCase() === lowered);
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    throw new Error(`Unknown CSV column: ${requested}`);
+}
+function getStrongDomainHeaderMatches(headers) {
+    return headers.filter((header) => STRONG_DOMAIN_HEADER_KEYS.has(normalizeHeaderKey(header)));
+}
+function getCandidateDomainColumns(headers) {
+    const strongMatches = getStrongDomainHeaderMatches(headers);
+    if (strongMatches.length > 0) {
+        return strongMatches;
+    }
+    return headers.filter((header) => {
+        const normalized = normalizeHeaderKey(header);
+        return CANDIDATE_DOMAIN_HEADER_TOKENS.some((token) => normalized.includes(token));
+    });
+}
+function isCarryoverJunkHeader(header) {
+    const normalized = normalizeHeaderKey(header);
+    if (!normalized) {
+        return true;
+    }
+    if (CARRYOVER_JUNK_KEYS.has(normalized)) {
+        return true;
+    }
+    return (normalized.endsWith("timestamp") ||
+        normalized.endsWith("createdat") ||
+        normalized.endsWith("updatedat"));
+}
+function getSuggestedCarryoverColumns(headers, domainColumn) {
+    return headers
+        .filter((header) => header !== domainColumn)
+        .filter((header) => !isCarryoverJunkHeader(header))
+        .slice(0, MAX_CSV_DOMAIN_CARRY_COLUMNS);
+}
+function makeSignature(payload) {
+    return createHmac("sha256", confirmationSecret)
+        .update(JSON.stringify(payload))
+        .digest("base64url");
+}
+function makeConfirmationEnvelope(payload) {
+    return {
+        payload,
+        signature: makeSignature(payload),
+    };
+}
+export function makeConfirmationToken(payload) {
+    return Buffer.from(JSON.stringify(makeConfirmationEnvelope(payload)), "utf8").toString("base64url");
+}
+export function parseConfirmationToken(token) {
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("Invalid confirmationToken. Run load_csv_domains preview again.");
+    }
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+        throw new Error("Invalid confirmationToken. Run load_csv_domains preview again.");
+    }
+    const envelope = decoded;
+    if (!envelope.payload ||
+        envelope.payload.version !== CONFIRMATION_TOKEN_VERSION ||
+        typeof envelope.signature !== "string") {
+        throw new Error("Invalid confirmationToken. Run load_csv_domains preview again.");
+    }
+    const expectedSignature = makeSignature(envelope.payload);
+    if (expectedSignature !== envelope.signature) {
+        throw new Error("Preview token is no longer valid. Re-run load_csv_domains preview.");
+    }
+    return envelope.payload;
+}
+export function matchesConfirmationToken(token, payload) {
+    const parsed = parseConfirmationToken(token);
+    return (parsed.filePath === payload.filePath &&
+        parsed.fileSizeBytes === payload.fileSizeBytes &&
+        parsed.fileMtimeMs === payload.fileMtimeMs &&
+        parsed.domainColumn === payload.domainColumn &&
+        compareStringArrays(parsed.selectedColumns, payload.selectedColumns));
+}
+export function parseCsvDomainFile(input) {
+    const resolvedFilePath = resolveCsvDomainPath(input.filePath, input.workspaceRoot);
+    const blockingErrors = [];
+    const warnings = [];
+    let stats;
+    try {
+        stats = statSync(resolvedFilePath);
+    }
+    catch (error) {
+        throw new Error(`Could not read CSV file at ${resolvedFilePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!stats.isFile()) {
+        throw new Error(`CSV path must point to a file: ${resolvedFilePath}`);
+    }
+    if (stats.size > MAX_CSV_DOMAIN_UPLOAD_BYTES) {
+        blockingErrors.push(`CSV file exceeds the ${MAX_CSV_DOMAIN_UPLOAD_BYTES} byte limit.`);
+    }
+    let rawRows;
+    try {
+        const content = readFileSync(resolvedFilePath, "utf8");
+        rawRows = parse(content, {
+            bom: true,
+            columns: false,
+            skip_empty_lines: true,
+            trim: true,
+            relax_column_count: true,
+        });
+    }
+    catch (error) {
+        throw new Error(`Could not parse CSV file at ${resolvedFilePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (rawRows.length === 0) {
+        blockingErrors.push("CSV file must include a header row.");
+        return {
+            resolvedFilePath,
+            fileSizeBytes: stats.size,
+            fileMtimeMs: stats.mtimeMs,
+            headers: [],
+            rows: [],
+            totalRows: 0,
+            blockingErrors,
+            warnings,
+        };
+    }
+    const headers = rawRows[0].map((value) => String(value ?? "").trim());
+    const dataRows = rawRows
+        .slice(1)
+        .map((row) => row.map((value) => String(value ?? "")));
+    if (headers.length === 0) {
+        blockingErrors.push("CSV file must include at least one header column.");
+    }
+    const blankHeaderCount = headers.filter((header) => header.length === 0).length;
+    if (blankHeaderCount > 0) {
+        blockingErrors.push("CSV header row contains blank column names.");
+    }
+    const duplicateHeaders = findDuplicateHeaders(headers);
+    if (duplicateHeaders.length > 0) {
+        blockingErrors.push(`CSV header row contains duplicate columns: ${duplicateHeaders.join(", ")}`);
+    }
+    const mismatchedRows = dataRows.filter((row) => row.length !== headers.length);
+    if (mismatchedRows.length > 0) {
+        blockingErrors.push(`CSV contains ${mismatchedRows.length} row(s) whose column count does not match the header row.`);
+    }
+    if (dataRows.length > MAX_CSV_DOMAIN_UPLOAD_ROWS) {
+        blockingErrors.push(`CSV contains ${dataRows.length} data rows, which exceeds the ${MAX_CSV_DOMAIN_UPLOAD_ROWS} row limit.`);
+    }
+    const rows = blockingErrors.length > 0 ? [] : buildRowObjects(headers, dataRows);
+    if (rows.length === 0 && dataRows.length === 0) {
+        warnings.push("CSV contains headers but no data rows.");
+    }
+    return {
+        resolvedFilePath,
+        fileSizeBytes: stats.size,
+        fileMtimeMs: stats.mtimeMs,
+        headers,
+        rows,
+        totalRows: dataRows.length,
+        blockingErrors,
+        warnings,
+    };
+}
+export function buildCsvDomainPreview(input) {
+    const parsed = parseCsvDomainFile(input);
+    const blockingErrors = [...parsed.blockingErrors];
+    const warnings = [...parsed.warnings];
+    const headers = parsed.headers;
+    let resolvedDomainColumn = null;
+    const strongMatches = getStrongDomainHeaderMatches(headers);
+    if (input.domainColumn) {
+        resolvedDomainColumn = resolveHeaderSelection(headers, input.domainColumn, "domainColumn");
+    }
+    else if (strongMatches.length === 1) {
+        resolvedDomainColumn = strongMatches[0];
+    }
+    else if (strongMatches.length > 1) {
+        warnings.push(`Multiple strong domain columns found: ${strongMatches.join(", ")}. Choose one explicitly.`);
+    }
+    const candidateDomainColumns = getCandidateDomainColumns(headers);
+    const suggestedCarryoverColumns = getSuggestedCarryoverColumns(headers, resolvedDomainColumn);
+    let resolvedSelectedColumns = [];
+    if (input.selectedColumns !== undefined) {
+        const seen = new Set();
+        resolvedSelectedColumns = input.selectedColumns.map((column) => {
+            const resolvedColumn = resolveHeaderSelection(headers, column, "selectedColumns");
+            if (resolvedDomainColumn && resolvedColumn === resolvedDomainColumn) {
+                throw new Error(`selectedColumns cannot include the chosen domain column (${resolvedDomainColumn}).`);
+            }
+            if (seen.has(resolvedColumn)) {
+                throw new Error(`selectedColumns contains duplicate column selection: ${resolvedColumn}`);
+            }
+            seen.add(resolvedColumn);
+            return resolvedColumn;
+        });
+        if (resolvedSelectedColumns.length > MAX_CSV_DOMAIN_CARRY_COLUMNS) {
+            throw new Error(`selectedColumns cannot contain more than ${MAX_CSV_DOMAIN_CARRY_COLUMNS} columns.`);
+        }
+    }
+    else {
+        resolvedSelectedColumns = suggestedCarryoverColumns;
+    }
+    const domainRows = parsed.rows;
+    let rowsWithChosenDomainValue = 0;
+    let duplicateDomainCount = 0;
+    let invalidDomainCount = 0;
+    let emptySelectedDomainRowCount = 0;
+    let uniqueCandidateDomains = 0;
+    let truncatedDomainCount = 0;
+    const keptCandidateDomains = [];
+    const seenDomains = new Set();
+    if (!resolvedDomainColumn) {
+        warnings.push("No strong domain column could be auto-detected. Re-run with domainColumn.");
+    }
+    if (resolvedDomainColumn && blockingErrors.length === 0) {
+        for (const row of domainRows) {
+            const rawValue = row[resolvedDomainColumn] ?? "";
+            const trimmedValue = rawValue.trim();
+            if (!trimmedValue) {
+                emptySelectedDomainRowCount += 1;
+                continue;
+            }
+            rowsWithChosenDomainValue += 1;
+            const sanitized = sanitizeCsvDomainCandidate(trimmedValue);
+            if (!sanitized.valid) {
+                invalidDomainCount += 1;
+                continue;
+            }
+            if (seenDomains.has(sanitized.cleaned)) {
+                duplicateDomainCount += 1;
+                continue;
+            }
+            seenDomains.add(sanitized.cleaned);
+            uniqueCandidateDomains += 1;
+            if (keptCandidateDomains.length < MAX_CSV_DOMAIN_UPLOAD_UNIQUE_DOMAINS) {
+                keptCandidateDomains.push(sanitized.cleaned);
+            }
+            else {
+                truncatedDomainCount += 1;
+            }
+        }
+    }
+    if (resolvedDomainColumn && rowsWithChosenDomainValue === 0) {
+        blockingErrors.push(`No rows contained a value in the selected domain column (${resolvedDomainColumn}).`);
+    }
+    if (resolvedDomainColumn && emptySelectedDomainRowCount > 0) {
+        blockingErrors.push(`Selected domain column (${resolvedDomainColumn}) contains ${emptySelectedDomainRowCount} empty row value(s).`);
+    }
+    if (resolvedDomainColumn && uniqueCandidateDomains === 0) {
+        blockingErrors.push("No candidate domains could be extracted from the selected domain column.");
+    }
+    const confirmationToken = resolvedDomainColumn && blockingErrors.length === 0
+        ? makeConfirmationToken({
+            version: CONFIRMATION_TOKEN_VERSION,
+            filePath: parsed.resolvedFilePath,
+            fileSizeBytes: parsed.fileSizeBytes,
+            fileMtimeMs: parsed.fileMtimeMs,
+            domainColumn: resolvedDomainColumn,
+            selectedColumns: resolvedSelectedColumns,
+        })
+        : null;
+    return {
+        preview: {
+            resolvedFilePath: parsed.resolvedFilePath,
+            headers,
+            detectedDomainColumn: resolvedDomainColumn,
+            candidateDomainColumns,
+            needsDomainColumnSelection: resolvedDomainColumn === null,
+            suggestedCarryoverColumns,
+            selectedColumns: resolvedSelectedColumns,
+            totalRows: parsed.totalRows,
+            rowsWithChosenDomainValue,
+            uniqueCandidateDomains,
+            duplicateDomainCount,
+            invalidDomainCount,
+            truncatedDomainCount,
+            emptySelectedDomainRowCount,
+            duplicatePolicy: "last_wins",
+            limits: getLimits(),
+            warnings,
+            blockingErrors,
+            confirmationToken,
+        },
+        fileSizeBytes: parsed.fileSizeBytes,
+        fileMtimeMs: parsed.fileMtimeMs,
+        resolvedDomainColumn,
+        parsedRows: domainRows,
+        keptCandidateDomains,
+    };
+}
+export function projectCsvCarryRows(previewBuild) {
+    if (!previewBuild.resolvedDomainColumn) {
+        return [];
+    }
+    const allowedDomains = new Set(previewBuild.keptCandidateDomains);
+    const columns = [
+        previewBuild.resolvedDomainColumn,
+        ...previewBuild.preview.selectedColumns,
+    ];
+    return previewBuild.parsedRows
+        .filter((row) => {
+        const sanitized = sanitizeCsvDomainCandidate(row[previewBuild.resolvedDomainColumn ?? ""] ?? "");
+        return sanitized.valid && allowedDomains.has(sanitized.cleaned);
+    })
+        .map((row) => {
+        const projected = {};
+        for (const column of columns) {
+            projected[column] = row[column] ?? "";
+        }
+        return projected;
+    });
+}

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

@@ -0,0 +1,102 @@
+import type { SellableApi } from "../api.js";
+export declare const MAX_CSV_LINKEDIN_UPLOAD_BYTES: number;
+export declare const MAX_CSV_LINKEDIN_UPLOAD_ROWS = 7500;
+export declare const MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS = 20;
+declare const CONFIRMATION_TOKEN_VERSION = "csv-linkedin-preview-v1";
+type StandardLeadListColumn = "Name" | "Title" | "Company Website" | "Location";
+export type CsvLinkedinLimits = {
+    maxBytes: number;
+    maxRows: number;
+    maxCarryColumns: number;
+};
+export type CsvLinkedinPreview = {
+    resolvedFilePath: string;
+    suggestedLeadListName: string;
+    headers: string[];
+    detectedLinkedInColumn: string | null;
+    candidateLinkedInColumns: string[];
+    needsLinkedInColumnSelection: boolean;
+    standardMappings: Partial<Record<StandardLeadListColumn, string | string[]>>;
+    customColumnTargets: string[];
+    suggestedCarryoverColumns: string[];
+    selectedColumns: string[];
+    totalRows: number;
+    validLinkedInRowCount: number;
+    invalidLinkedInRowCount: number;
+    duplicateLinkedInCount: number;
+    emptyLinkedInRowCount: number;
+    duplicatePolicy: "first_wins";
+    limits: CsvLinkedinLimits;
+    warnings: string[];
+    blockingErrors: string[];
+    confirmationToken: string | null;
+};
+export type CsvLinkedinConfirmationPayload = {
+    version: typeof CONFIRMATION_TOKEN_VERSION;
+    filePath: string;
+    fileSizeBytes: number;
+    fileMtimeMs: number;
+    linkedInColumn: string;
+    selectedColumns: string[];
+};
+export type PreparedLinkedinLeadRow = {
+    row: Record<string, string>;
+    normalizedLinkedInUrl: string;
+};
+export type CsvLinkedinPreviewBuild = {
+    preview: CsvLinkedinPreview;
+    fileSizeBytes: number;
+    fileMtimeMs: number;
+    resolvedLinkedInColumn: string | null;
+    parsedRows: Array<Record<string, string>>;
+    preparedRows: PreparedLinkedinLeadRow[];
+};
+export type CsvLinkedinUploadResult = {
+    bucket: string;
+    objectPath: string;
+    token: string;
+    signedUrl: string;
+    originalFilename: string;
+    contentType: string;
+    fileSizeBytes: number;
+};
+type ParseCsvLinkedinFileInput = {
+    filePath: string;
+    workspaceRoot?: string;
+};
+type BuildCsvLinkedinPreviewInput = ParseCsvLinkedinFileInput & {
+    linkedInColumn?: string;
+    selectedColumns?: string[];
+};
+type ParsedCsvLinkedinFile = {
+    resolvedFilePath: string;
+    suggestedLeadListName: string;
+    fileSizeBytes: number;
+    fileMtimeMs: number;
+    headers: string[];
+    rows: Array<Record<string, string>>;
+    totalRows: number;
+    blockingErrors: string[];
+    warnings: string[];
+};
+export declare function makeLinkedinConfirmationToken(payload: CsvLinkedinConfirmationPayload): string;
+export declare function parseLinkedinConfirmationToken(token: string): CsvLinkedinConfirmationPayload;
+export declare function matchesLinkedinConfirmationToken(token: string, payload: CsvLinkedinConfirmationPayload): boolean;
+export declare function parseCsvLinkedinFile(input: ParseCsvLinkedinFileInput): ParsedCsvLinkedinFile;
+export declare function buildCsvLinkedinPreview(input: BuildCsvLinkedinPreviewInput): CsvLinkedinPreviewBuild;
+export declare function uploadCsvLinkedinFile(params: {
+    api: Pick<SellableApi, "post">;
+    leadListId: string;
+    filePath: string;
+    workspaceRoot?: string;
+    fileSizeBytes?: number;
+}): Promise<{
+    originalFilename: string;
+    contentType: string;
+    fileSizeBytes: number;
+    bucket: string;
+    objectPath: string;
+    token: string;
+    signedUrl: string;
+}>;
+export {};