@sellable/mcp 0.1.0

package/dist/tools/csv-linkedin.js

@@ -0,0 +1,712 @@
+import { parse } from "csv-parse/sync";
+import { createHmac, randomBytes } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { basename, dirname, extname, 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_LINKEDIN_UPLOAD_BYTES = 5 * 1024 * 1024;
+export const MAX_CSV_LINKEDIN_UPLOAD_ROWS = 7500;
+export const MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS = 20;
+const CONFIRMATION_TOKEN_VERSION = "csv-linkedin-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_LINKEDIN_HEADER_KEYS = new Set([
+    "linkedin",
+    "linkedinurl",
+    "linkedinprofile",
+    "linkedinprofileurl",
+    "profileurl",
+    "personlinkedin",
+]);
+const CANDIDATE_LINKEDIN_HEADER_TOKENS = ["linkedin", "profile", "public"];
+const CARRYOVER_JUNK_KEYS = new Set([
+    "id",
+    "_id",
+    "rowid",
+    "row_id",
+    "createdat",
+    "updatedat",
+    "timestamp",
+    "created",
+    "updated",
+]);
+const RESERVED_TARGET_COLUMNS = new Set([
+    "Name",
+    "Title",
+    "Company Website",
+    "Location",
+    "LinkedIn URL",
+    "Open Link",
+    "Enrich Prospect",
+]);
+const CSV_LINKEDIN_LIMITS = {
+    maxBytes: MAX_CSV_LINKEDIN_UPLOAD_BYTES,
+    maxRows: MAX_CSV_LINKEDIN_UPLOAD_ROWS,
+    maxCarryColumns: MAX_CSV_LINKEDIN_UPLOAD_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_LINKEDIN_LIMITS };
+}
+function resolveCsvLinkedinPath(filePath, workspaceRoot = defaultWorkspaceRoot) {
+    if (!filePath || typeof filePath !== "string") {
+        throw new Error("load_csv_linkedin_leads requires a non-empty filePath.");
+    }
+    return isAbsolute(filePath)
+        ? resolve(filePath)
+        : resolve(workspaceRoot, filePath);
+}
+function getCsvLinkedinContentType(filePath) {
+    return extname(filePath).toLowerCase() === ".txt" ? "text/plain" : "text/csv";
+}
+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 getStrongLinkedInHeaderMatches(headers) {
+    return headers.filter((header) => STRONG_LINKEDIN_HEADER_KEYS.has(normalizeHeaderKey(header)));
+}
+function looksLikeLinkedInProfileUrl(value) {
+    const lowered = value.toLowerCase();
+    return (lowered.includes("linkedin.com/in/") && !lowered.includes("/sales/lead/"));
+}
+function detectLinkedInColumnByContent(rows, headers) {
+    if (rows.length === 0 || headers.length === 0) {
+        return { detectedColumn: null, candidateColumns: [] };
+    }
+    const sampleRows = rows.slice(0, 5);
+    const scores = headers.map((header) => ({
+        header,
+        score: sampleRows.reduce((count, row) => {
+            return looksLikeLinkedInProfileUrl(String(row[header] ?? "").trim())
+                ? count + 1
+                : count;
+        }, 0),
+    }));
+    const maxScore = Math.max(...scores.map((entry) => entry.score));
+    if (maxScore <= 0) {
+        return { detectedColumn: null, candidateColumns: [] };
+    }
+    const candidates = scores
+        .filter((entry) => entry.score === maxScore)
+        .map((entry) => entry.header);
+    return {
+        detectedColumn: candidates.length === 1 ? candidates[0] : null,
+        candidateColumns: candidates,
+    };
+}
+function getCandidateLinkedInColumns(headers, rows) {
+    const strongMatches = getStrongLinkedInHeaderMatches(headers);
+    if (strongMatches.length > 0) {
+        return strongMatches;
+    }
+    const contentDetection = detectLinkedInColumnByContent(rows, headers);
+    if (contentDetection.candidateColumns.length > 0) {
+        return contentDetection.candidateColumns;
+    }
+    return headers.filter((header) => {
+        const normalized = normalizeHeaderKey(header);
+        return CANDIDATE_LINKEDIN_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 normalizeHeaderForLookup(header) {
+    return header.toLowerCase().replace(/[_-]/g, " ").replace(/\s+/g, " ").trim();
+}
+function findHeader(csvHeaders, normalizedHeaders, candidates) {
+    const exactMatchIndex = normalizedHeaders.findIndex((normalizedHeader) => candidates.some((candidate) => normalizedHeader === candidate));
+    if (exactMatchIndex !== -1) {
+        return csvHeaders[exactMatchIndex];
+    }
+    for (let index = 0; index < normalizedHeaders.length; index += 1) {
+        const normalizedHeader = normalizedHeaders[index];
+        if (candidates.some((candidate) => candidate.includes(" ") && normalizedHeader.includes(candidate))) {
+            return csvHeaders[index];
+        }
+    }
+    return undefined;
+}
+function getSuggestedStandardMappings(headers, linkedInColumn) {
+    const filteredHeaders = headers.filter((header) => header !== linkedInColumn);
+    const normalizedHeaders = filteredHeaders.map(normalizeHeaderForLookup);
+    const mappings = {};
+    const directNameHeader = findHeader(filteredHeaders, normalizedHeaders, [
+        "name",
+        "full name",
+        "contact name",
+    ]);
+    if (directNameHeader) {
+        mappings["Name"] = directNameHeader;
+    }
+    else {
+        const firstNameIndex = normalizedHeaders.findIndex((header) => header === "first name");
+        const lastNameIndex = normalizedHeaders.findIndex((header) => header === "last name");
+        if (firstNameIndex !== -1 && lastNameIndex !== -1) {
+            mappings["Name"] = [
+                filteredHeaders[firstNameIndex],
+                filteredHeaders[lastNameIndex],
+            ];
+        }
+    }
+    const titleHeader = findHeader(filteredHeaders, normalizedHeaders, [
+        "title",
+        "job title",
+        "position",
+        "role",
+    ]);
+    if (titleHeader) {
+        mappings["Title"] = titleHeader;
+    }
+    const companyWebsiteHeader = findHeader(filteredHeaders, normalizedHeaders, [
+        "company website",
+        "website",
+        "domain",
+        "company domain",
+        "website url",
+        "company url",
+        "organization website",
+    ]);
+    if (companyWebsiteHeader) {
+        mappings["Company Website"] = companyWebsiteHeader;
+    }
+    const locationHeader = findHeader(filteredHeaders, normalizedHeaders, [
+        "location",
+        "city",
+        "geography",
+        "region",
+    ]);
+    if (locationHeader) {
+        mappings["Location"] = locationHeader;
+    }
+    return mappings;
+}
+function getSuggestedCarryoverColumns(headers, linkedInColumn, standardMappings) {
+    const prioritized = [];
+    const seen = new Set();
+    const addHeader = (header) => {
+        if (!header || header === linkedInColumn || seen.has(header)) {
+            return;
+        }
+        seen.add(header);
+        prioritized.push(header);
+    };
+    for (const mapping of Object.values(standardMappings)) {
+        if (Array.isArray(mapping)) {
+            mapping.forEach(addHeader);
+            continue;
+        }
+        if (mapping) {
+            addHeader(mapping);
+        }
+    }
+    headers
+        .filter((header) => header !== linkedInColumn)
+        .filter((header) => !isCarryoverJunkHeader(header))
+        .forEach(addHeader);
+    return prioritized.slice(0, MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS);
+}
+function buildLeadListNameSuggestion(resolvedFilePath) {
+    const fileName = basename(resolvedFilePath);
+    const extension = extname(fileName);
+    const baseName = extension ? fileName.slice(0, -extension.length) : fileName;
+    return baseName.trim() || "LinkedIn Upload";
+}
+function sanitizeCompanyWebsite(value) {
+    let cleaned = value.trim().toLowerCase();
+    if (!cleaned) {
+        return null;
+    }
+    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 || cleaned.includes(" ") || cleaned.includes("@")) {
+        return null;
+    }
+    if (!DOMAIN_REGEX.test(cleaned)) {
+        return null;
+    }
+    return cleaned;
+}
+function validateAndNormalizeLinkedInUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return { valid: false, reason: "Empty LinkedIn URL" };
+    }
+    if (!trimmed.toLowerCase().includes("linkedin.com")) {
+        return { valid: false, reason: "Not a LinkedIn URL" };
+    }
+    if (trimmed.toLowerCase().includes("/sales/lead/")) {
+        return {
+            valid: false,
+            reason: "Sales Navigator lead URLs are not supported",
+        };
+    }
+    let parsed;
+    try {
+        parsed = new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`);
+    }
+    catch {
+        return { valid: false, reason: "Invalid URL" };
+    }
+    const host = parsed.hostname.toLowerCase();
+    if (host !== "linkedin.com" && host !== "www.linkedin.com") {
+        return {
+            valid: false,
+            reason: "LinkedIn profile URLs must use linkedin.com",
+        };
+    }
+    const path = parsed.pathname.replace(/\/+$/, "");
+    const match = path.match(/^\/in\/([^/?#]+)$/i);
+    if (!match?.[1]) {
+        return { valid: false, reason: "LinkedIn profile URLs must use /in/" };
+    }
+    const profileId = decodeURIComponent(match[1]).trim();
+    if (!profileId) {
+        return { valid: false, reason: "LinkedIn profile ID is empty" };
+    }
+    if (!/^[\p{L}\p{N}_.~\-]+$/u.test(profileId)) {
+        return {
+            valid: false,
+            reason: "LinkedIn profile ID contains unsupported characters",
+        };
+    }
+    return {
+        valid: true,
+        normalizedUrl: `https://linkedin.com/in/${profileId}`,
+    };
+}
+function makeSignature(payload) {
+    return createHmac("sha256", confirmationSecret)
+        .update(JSON.stringify(payload))
+        .digest("base64url");
+}
+function makeConfirmationEnvelope(payload) {
+    return {
+        payload,
+        signature: makeSignature(payload),
+    };
+}
+export function makeLinkedinConfirmationToken(payload) {
+    return Buffer.from(JSON.stringify(makeConfirmationEnvelope(payload)), "utf8").toString("base64url");
+}
+export function parseLinkedinConfirmationToken(token) {
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("Invalid confirmationToken. Run load_csv_linkedin_leads preview again.");
+    }
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+        throw new Error("Invalid confirmationToken. Run load_csv_linkedin_leads 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_linkedin_leads preview again.");
+    }
+    const expectedSignature = makeSignature(envelope.payload);
+    if (expectedSignature !== envelope.signature) {
+        throw new Error("Preview token is no longer valid. Re-run load_csv_linkedin_leads preview.");
+    }
+    return envelope.payload;
+}
+export function matchesLinkedinConfirmationToken(token, payload) {
+    const parsed = parseLinkedinConfirmationToken(token);
+    return (parsed.filePath === payload.filePath &&
+        parsed.fileSizeBytes === payload.fileSizeBytes &&
+        parsed.fileMtimeMs === payload.fileMtimeMs &&
+        parsed.linkedInColumn === payload.linkedInColumn &&
+        compareStringArrays(parsed.selectedColumns, payload.selectedColumns));
+}
+export function parseCsvLinkedinFile(input) {
+    const resolvedFilePath = resolveCsvLinkedinPath(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_LINKEDIN_UPLOAD_BYTES) {
+        blockingErrors.push(`CSV file exceeds the ${MAX_CSV_LINKEDIN_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,
+            suggestedLeadListName: buildLeadListNameSuggestion(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_LINKEDIN_UPLOAD_ROWS) {
+        blockingErrors.push(`CSV contains ${dataRows.length} data rows, which exceeds the ${MAX_CSV_LINKEDIN_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,
+        suggestedLeadListName: buildLeadListNameSuggestion(resolvedFilePath),
+        fileSizeBytes: stats.size,
+        fileMtimeMs: stats.mtimeMs,
+        headers,
+        rows,
+        totalRows: dataRows.length,
+        blockingErrors,
+        warnings,
+    };
+}
+function filterStandardMappingsToSelection(selectedColumns, standardMappings) {
+    const selectedSet = new Set(selectedColumns);
+    const filtered = {};
+    for (const [target, mapping] of Object.entries(standardMappings)) {
+        if (Array.isArray(mapping)) {
+            if (mapping.every((header) => selectedSet.has(header))) {
+                filtered[target] = mapping;
+            }
+            continue;
+        }
+        if (selectedSet.has(mapping)) {
+            filtered[target] = mapping;
+        }
+    }
+    return filtered;
+}
+function prepareLeadRows(params) {
+    const effectiveStandardMappings = filterStandardMappingsToSelection(params.selectedColumns, params.standardMappings);
+    const consumedSources = new Set();
+    for (const mapping of Object.values(effectiveStandardMappings)) {
+        if (Array.isArray(mapping)) {
+            mapping.forEach((header) => consumedSources.add(header));
+            continue;
+        }
+        consumedSources.add(mapping);
+    }
+    const customColumns = params.selectedColumns.filter((header) => !consumedSources.has(header) && !RESERVED_TARGET_COLUMNS.has(header));
+    const seenLinkedInUrls = new Set();
+    const preparedRows = [];
+    let invalidCount = 0;
+    let duplicateCount = 0;
+    let emptyCount = 0;
+    for (const sourceRow of params.rows) {
+        const linkedInValue = String(sourceRow[params.linkedInColumn] ?? "").trim();
+        if (!linkedInValue) {
+            emptyCount += 1;
+            continue;
+        }
+        const validation = validateAndNormalizeLinkedInUrl(linkedInValue);
+        if (!validation.valid) {
+            invalidCount += 1;
+            continue;
+        }
+        const dedupeKey = validation.normalizedUrl.toLowerCase();
+        if (seenLinkedInUrls.has(dedupeKey)) {
+            duplicateCount += 1;
+            continue;
+        }
+        seenLinkedInUrls.add(dedupeKey);
+        const row = {
+            "LinkedIn URL": validation.normalizedUrl,
+        };
+        for (const [target, mapping] of Object.entries(effectiveStandardMappings)) {
+            if (Array.isArray(mapping)) {
+                const parts = mapping
+                    .map((header) => String(sourceRow[header] ?? "").trim())
+                    .filter(Boolean);
+                if (parts.length > 0) {
+                    row[target] = parts.join(" ");
+                }
+                continue;
+            }
+            const value = String(sourceRow[mapping] ?? "").trim();
+            if (!value) {
+                continue;
+            }
+            if (target === "Company Website") {
+                const normalizedWebsite = sanitizeCompanyWebsite(value);
+                if (normalizedWebsite) {
+                    row[target] = normalizedWebsite;
+                }
+                continue;
+            }
+            row[target] = value;
+        }
+        for (const customColumn of customColumns) {
+            const value = String(sourceRow[customColumn] ?? "").trim();
+            if (value) {
+                row[customColumn] = value;
+            }
+        }
+        preparedRows.push({
+            row,
+            normalizedLinkedInUrl: validation.normalizedUrl,
+        });
+    }
+    return {
+        rows: preparedRows,
+        standardMappings: effectiveStandardMappings,
+        customColumnTargets: customColumns,
+        invalidCount,
+        duplicateCount,
+        emptyCount,
+    };
+}
+export function buildCsvLinkedinPreview(input) {
+    const parsed = parseCsvLinkedinFile(input);
+    const blockingErrors = [...parsed.blockingErrors];
+    const warnings = [...parsed.warnings];
+    const headers = parsed.headers;
+    let resolvedLinkedInColumn = null;
+    const strongMatches = getStrongLinkedInHeaderMatches(headers);
+    if (input.linkedInColumn) {
+        resolvedLinkedInColumn = resolveHeaderSelection(headers, input.linkedInColumn, "linkedInColumn");
+    }
+    else if (strongMatches.length === 1) {
+        resolvedLinkedInColumn = strongMatches[0];
+    }
+    else if (strongMatches.length > 1) {
+        warnings.push(`Multiple LinkedIn-looking headers found (${strongMatches.join(", ")}). Set linkedInColumn explicitly.`);
+    }
+    else {
+        const contentDetection = detectLinkedInColumnByContent(parsed.rows, headers);
+        if (contentDetection.detectedColumn) {
+            resolvedLinkedInColumn = contentDetection.detectedColumn;
+        }
+        else if (contentDetection.candidateColumns.length > 1) {
+            warnings.push(`Multiple columns look like LinkedIn profile URLs (${contentDetection.candidateColumns.join(", ")}). Set linkedInColumn explicitly.`);
+        }
+    }
+    const candidateLinkedInColumns = getCandidateLinkedInColumns(headers, parsed.rows);
+    const standardMappings = getSuggestedStandardMappings(headers, resolvedLinkedInColumn);
+    let selectedColumns = getSuggestedCarryoverColumns(headers, resolvedLinkedInColumn, standardMappings);
+    if (input.selectedColumns) {
+        if (input.selectedColumns.length > MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS) {
+            blockingErrors.push(`selectedColumns exceeds the ${MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS} column limit.`);
+        }
+        else {
+            selectedColumns = input.selectedColumns.map((column) => resolveHeaderSelection(headers, column, "selectedColumns"));
+            if (resolvedLinkedInColumn &&
+                selectedColumns.includes(resolvedLinkedInColumn)) {
+                blockingErrors.push("selectedColumns cannot include the chosen LinkedIn URL column.");
+            }
+            selectedColumns = selectedColumns.filter((column, index, array) => array.indexOf(column) === index);
+        }
+    }
+    const prepared = resolvedLinkedInColumn
+        ? prepareLeadRows({
+            rows: parsed.rows,
+            linkedInColumn: resolvedLinkedInColumn,
+            selectedColumns,
+            standardMappings,
+        })
+        : {
+            rows: [],
+            standardMappings: {},
+            customColumnTargets: [],
+            invalidCount: 0,
+            duplicateCount: 0,
+            emptyCount: 0,
+        };
+    if (resolvedLinkedInColumn && prepared.rows.length === 0) {
+        blockingErrors.push("CSV did not produce any valid LinkedIn profile URLs after validation.");
+    }
+    if (prepared.invalidCount > 0) {
+        warnings.push(`Skipped ${prepared.invalidCount} invalid LinkedIn URL row(s).`);
+    }
+    if (prepared.duplicateCount > 0) {
+        warnings.push(`Skipped ${prepared.duplicateCount} duplicate LinkedIn URL row(s) using first_wins.`);
+    }
+    if (prepared.emptyCount > 0) {
+        warnings.push(`Skipped ${prepared.emptyCount} row(s) with an empty LinkedIn URL value.`);
+    }
+    const payload = blockingErrors.length === 0 && resolvedLinkedInColumn
+        ? {
+            version: CONFIRMATION_TOKEN_VERSION,
+            filePath: parsed.resolvedFilePath,
+            fileSizeBytes: parsed.fileSizeBytes,
+            fileMtimeMs: parsed.fileMtimeMs,
+            linkedInColumn: resolvedLinkedInColumn,
+            selectedColumns,
+        }
+        : null;
+    return {
+        preview: {
+            resolvedFilePath: parsed.resolvedFilePath,
+            suggestedLeadListName: parsed.suggestedLeadListName,
+            headers,
+            detectedLinkedInColumn: resolvedLinkedInColumn,
+            candidateLinkedInColumns,
+            needsLinkedInColumnSelection: !resolvedLinkedInColumn,
+            standardMappings: prepared.standardMappings,
+            customColumnTargets: prepared.customColumnTargets,
+            suggestedCarryoverColumns: getSuggestedCarryoverColumns(headers, resolvedLinkedInColumn, standardMappings),
+            selectedColumns,
+            totalRows: parsed.totalRows,
+            validLinkedInRowCount: prepared.rows.length,
+            invalidLinkedInRowCount: prepared.invalidCount,
+            duplicateLinkedInCount: prepared.duplicateCount,
+            emptyLinkedInRowCount: prepared.emptyCount,
+            duplicatePolicy: "first_wins",
+            limits: getLimits(),
+            warnings,
+            blockingErrors,
+            confirmationToken: payload
+                ? makeLinkedinConfirmationToken(payload)
+                : null,
+        },
+        fileSizeBytes: parsed.fileSizeBytes,
+        fileMtimeMs: parsed.fileMtimeMs,
+        resolvedLinkedInColumn,
+        parsedRows: parsed.rows,
+        preparedRows: prepared.rows,
+    };
+}
+export async function uploadCsvLinkedinFile(params) {
+    const resolvedFilePath = resolveCsvLinkedinPath(params.filePath, params.workspaceRoot);
+    const originalFilename = basename(resolvedFilePath);
+    const fileBytes = readFileSync(resolvedFilePath);
+    const fileSizeBytes = params.fileSizeBytes ?? fileBytes.byteLength;
+    const contentType = getCsvLinkedinContentType(resolvedFilePath);
+    const uploadContract = await params.api.post(`/api/v3/lead-lists/${params.leadListId}/csv-import/upload-url`, {
+        filename: originalFilename,
+        contentType,
+        fileSizeBytes,
+    });
+    const uploadResponse = await fetch(uploadContract.signedUrl, {
+        method: "PUT",
+        headers: {
+            "content-type": contentType,
+            "cache-control": "max-age=3600",
+            "x-upsert": "false",
+        },
+        body: fileBytes,
+    });
+    if (!uploadResponse.ok) {
+        const errorText = await uploadResponse.text();
+        throw new Error(`Signed CSV upload failed (${uploadResponse.status}): ${errorText || uploadResponse.statusText}`);
+    }
+    return {
+        ...uploadContract,
+        originalFilename,
+        contentType,
+        fileSizeBytes,
+    };
+}