@sellable/mcp 0.1.253 → 0.1.254

package/dist/tools/csv-dnc.js

@@ -0,0 +1,651 @@
+import { parse } from "csv-parse/sync";
+import { createHash, createHmac, randomBytes } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { getApi } from "../api.js";
+import { getConfig } from "../auth.js";
+import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
+import { sanitizeCsvDomainCandidate } from "./csv-domains.js";
+import { validateAndNormalizeLinkedInUrl } from "./csv-linkedin.js";
+const entryPath = process.argv[1] ? resolve(process.argv[1]) : process.cwd();
+const entryDir = dirname(entryPath);
+const workspaceRoot = resolveWorkspaceRoot(entryDir);
+const CONFIRMATION_TOKEN_VERSION = "csv-dnc-preview-v1";
+const confirmationSecret = randomBytes(32).toString("hex");
+const MAX_DNC_UPLOAD_BYTES = 5 * 1024 * 1024;
+const MAX_DNC_CANDIDATES = 7500;
+const STRONG_DOMAIN_HEADER_KEYS = new Set([
+    "domain",
+    "website",
+    "companydomain",
+    "companywebsite",
+    "url",
+    "homepage",
+]);
+const DOMAIN_HEADER_TOKENS = ["domain", "website", "url", "homepage", "site"];
+const STRONG_LINKEDIN_HEADER_KEYS = new Set([
+    "linkedin",
+    "linkedinurl",
+    "linkedinprofile",
+    "linkedinprofileurl",
+    "profileurl",
+    "personlinkedin",
+]);
+const LINKEDIN_HEADER_TOKENS = ["linkedin", "profile", "public"];
+function normalizeHeaderKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "");
+}
+function hashText(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function hashEntry(entry) {
+    return hashText(`${entry.type}:${entry.value.toLowerCase()}`);
+}
+function compareStringArrays(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((value, index) => value === right[index]);
+}
+function normalizeListName(value) {
+    const trimmed = String(value ?? "").trim();
+    return trimmed || "MCP DNC Import";
+}
+function resolveSource(input) {
+    const supplied = [input.filePath, input.csvText, input.rawText].filter((value) => typeof value === "string" && value.trim());
+    if (supplied.length !== 1) {
+        throw new Error("load_csv_dnc_entries requires exactly one of filePath, csvText, or rawText.");
+    }
+    if (input.filePath?.trim()) {
+        const resolvedFilePath = isAbsolute(input.filePath)
+            ? resolve(input.filePath)
+            : resolve(workspaceRoot, input.filePath);
+        let stats;
+        try {
+            stats = statSync(resolvedFilePath);
+        }
+        catch (error) {
+            throw new Error(`Could not read DNC CSV file at ${resolvedFilePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!stats.isFile()) {
+            throw new Error(`DNC CSV path must point to a file: ${resolvedFilePath}`);
+        }
+        if (stats.size > MAX_DNC_UPLOAD_BYTES) {
+            throw new Error(`DNC CSV file exceeds the ${MAX_DNC_UPLOAD_BYTES} byte limit.`);
+        }
+        const content = readFileSync(resolvedFilePath, "utf8");
+        return {
+            kind: "file",
+            resolvedFilePath,
+            fileSizeBytes: stats.size,
+            fileMtimeMs: stats.mtimeMs,
+            contentHash: hashText(content),
+            content,
+        };
+    }
+    if (input.csvText?.trim()) {
+        return {
+            kind: "csvText",
+            contentHash: hashText(input.csvText),
+            content: input.csvText,
+        };
+    }
+    return {
+        kind: "rawText",
+        contentHash: hashText(input.rawText ?? ""),
+        content: input.rawText ?? "",
+    };
+}
+function parseCsvRows(content) {
+    const blockingErrors = [];
+    let rawRows;
+    try {
+        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 DNC CSV input: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (rawRows.length === 0) {
+        return {
+            headers: [],
+            rows: [],
+            blockingErrors: ["CSV input must include a header row."],
+        };
+    }
+    const headers = rawRows[0].map((value) => String(value ?? "").trim());
+    const dataRows = rawRows
+        .slice(1)
+        .map((row) => row.map((value) => String(value ?? "")));
+    if (headers.some((header) => !header)) {
+        blockingErrors.push("CSV header row contains blank column names.");
+    }
+    const seenHeaders = new Set();
+    const duplicateHeaders = new Set();
+    for (const header of headers) {
+        const normalized = header.trim().toLowerCase();
+        if (!normalized)
+            continue;
+        if (seenHeaders.has(normalized)) {
+            duplicateHeaders.add(header);
+        }
+        seenHeaders.add(normalized);
+    }
+    if (duplicateHeaders.size > 0) {
+        blockingErrors.push(`CSV header row contains duplicate columns: ${Array.from(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 (blockingErrors.length > 0) {
+        return { headers, rows: [], blockingErrors };
+    }
+    return {
+        headers,
+        rows: dataRows.map((row) => {
+            const out = {};
+            headers.forEach((header, index) => {
+                out[header] = String(row[index] ?? "");
+            });
+            return out;
+        }),
+        blockingErrors,
+    };
+}
+function resolveHeaderSelection(headers, requested) {
+    const trimmed = requested.trim();
+    if (!trimmed)
+        throw new Error("CSV column names must be non-empty strings.");
+    const exact = headers.find((header) => header === trimmed);
+    if (exact)
+        return exact;
+    const matches = headers.filter((header) => header.trim().toLowerCase() === trimmed.toLowerCase());
+    if (matches.length === 1)
+        return matches[0];
+    throw new Error(`Unknown CSV column: ${requested}`);
+}
+function matchingColumns(headers, kind) {
+    const strongKeys = kind === "domain" ? STRONG_DOMAIN_HEADER_KEYS : STRONG_LINKEDIN_HEADER_KEYS;
+    const weakTokens = kind === "domain" ? DOMAIN_HEADER_TOKENS : LINKEDIN_HEADER_TOKENS;
+    const strong = headers.filter((header) => strongKeys.has(normalizeHeaderKey(header)));
+    if (strong.length > 0)
+        return strong;
+    return headers.filter((header) => {
+        const normalized = normalizeHeaderKey(header);
+        if (kind === "domain" &&
+            (normalized.includes("linkedin") || normalized.includes("profile"))) {
+            return false;
+        }
+        return weakTokens.some((token) => normalized.includes(token));
+    });
+}
+function detectColumns(params) {
+    const warnings = [];
+    const blockingErrors = [];
+    const candidateDomainColumns = matchingColumns(params.headers, "domain");
+    const candidateLinkedInColumns = matchingColumns(params.headers, "linkedin");
+    let domainColumn = null;
+    let linkedInColumn = null;
+    if (params.domainColumn) {
+        domainColumn = resolveHeaderSelection(params.headers, params.domainColumn);
+    }
+    else if (candidateDomainColumns.length === 1) {
+        domainColumn = candidateDomainColumns[0];
+    }
+    else if (candidateDomainColumns.length > 1) {
+        blockingErrors.push(`Multiple possible domain columns found: ${candidateDomainColumns.join(", ")}. Re-run with domainColumn.`);
+    }
+    if (params.linkedInColumn) {
+        linkedInColumn = resolveHeaderSelection(params.headers, params.linkedInColumn);
+    }
+    else if (candidateLinkedInColumns.length === 1) {
+        linkedInColumn = candidateLinkedInColumns[0];
+    }
+    else if (candidateLinkedInColumns.length > 1) {
+        blockingErrors.push(`Multiple possible LinkedIn profile columns found: ${candidateLinkedInColumns.join(", ")}. Re-run with linkedInColumn.`);
+    }
+    if (!domainColumn && !linkedInColumn) {
+        warnings.push("No DNC domain or LinkedIn profile column could be auto-detected.");
+        blockingErrors.push("Choose a domainColumn, linkedInColumn, or paste a raw list of domains and LinkedIn profile URLs.");
+    }
+    return {
+        domainColumn,
+        linkedInColumn,
+        candidateDomainColumns,
+        candidateLinkedInColumns,
+        warnings,
+        blockingErrors,
+    };
+}
+function addDomainCandidate(params) {
+    const trimmed = params.value.trim();
+    if (!trimmed)
+        return;
+    const sanitized = sanitizeCsvDomainCandidate(trimmed);
+    if (!sanitized.valid) {
+        params.invalidRows.push({
+            row: params.row,
+            column: params.column,
+            value: trimmed,
+            reason: sanitized.reason,
+        });
+        return;
+    }
+    params.candidates.push({
+        type: "domain",
+        value: sanitized.cleaned,
+        sourceRow: params.row,
+        sourceColumn: params.column,
+    });
+}
+function addLinkedInCandidate(params) {
+    const trimmed = params.value.trim();
+    if (!trimmed)
+        return;
+    const normalized = validateAndNormalizeLinkedInUrl(trimmed);
+    if (!normalized.valid) {
+        params.invalidRows.push({
+            row: params.row,
+            column: params.column,
+            value: trimmed,
+            reason: normalized.reason,
+        });
+        return;
+    }
+    params.candidates.push({
+        type: "linkedin",
+        value: normalized.normalizedUrl,
+        sourceRow: params.row,
+        sourceColumn: params.column,
+    });
+}
+function parseRawDncValues(content) {
+    const candidates = [];
+    const invalidRows = [];
+    const values = content
+        .split(/[\n,]/)
+        .map((value) => value.replace(/^[-*]\s*/, "").trim())
+        .filter(Boolean);
+    values.forEach((value, index) => {
+        const linkedIn = validateAndNormalizeLinkedInUrl(value);
+        if (linkedIn.valid) {
+            candidates.push({
+                type: "linkedin",
+                value: linkedIn.normalizedUrl,
+                sourceRow: index + 1,
+                sourceColumn: null,
+            });
+            return;
+        }
+        const domain = sanitizeCsvDomainCandidate(value);
+        if (domain.valid) {
+            candidates.push({
+                type: "domain",
+                value: domain.cleaned,
+                sourceRow: index + 1,
+                sourceColumn: null,
+            });
+            return;
+        }
+        invalidRows.push({
+            row: index + 1,
+            column: null,
+            value,
+            reason: value.toLowerCase().includes("linkedin.com") && !linkedIn.valid
+                ? linkedIn.reason
+                : domain.reason,
+        });
+    });
+    return { candidates, invalidRows, totalRows: values.length };
+}
+function dedupeCandidates(candidates) {
+    const seen = new Set();
+    const deduped = [];
+    let duplicateCount = 0;
+    for (const candidate of candidates) {
+        const key = `${candidate.type}:${candidate.value.toLowerCase()}`;
+        if (seen.has(key)) {
+            duplicateCount += 1;
+            continue;
+        }
+        seen.add(key);
+        deduped.push(candidate);
+    }
+    return { deduped, duplicateCount };
+}
+async function getVerifiedActiveWorkspace() {
+    const config = getConfig();
+    const activeWorkspaceId = config.activeWorkspaceId || config.workspaceId;
+    if (!activeWorkspaceId) {
+        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before importing DNC entries.");
+    }
+    const api = getApi();
+    const { workspaces } = await api.get("/api/v3/workspaces");
+    const match = workspaces.find((workspace) => workspace.id === activeWorkspaceId);
+    if (!match) {
+        throw new Error(`Active workspace ${activeWorkspaceId} is not in the server access list. Run list_workspaces then set_active_workspace for the workspace that should receive the DNC import.`);
+    }
+    return match;
+}
+function makeSignature(payload) {
+    return createHmac("sha256", confirmationSecret)
+        .update(JSON.stringify(payload))
+        .digest("base64url");
+}
+function makeConfirmationToken(payload) {
+    return Buffer.from(JSON.stringify({ payload, signature: makeSignature(payload) }), "utf8").toString("base64url");
+}
+function parseConfirmationToken(token) {
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+    }
+    catch {
+        throw new Error("Invalid confirmationToken. Run load_csv_dnc_entries preview again.");
+    }
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+        throw new Error("Invalid confirmationToken. Run load_csv_dnc_entries 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_dnc_entries preview again.");
+    }
+    if (makeSignature(envelope.payload) !== envelope.signature) {
+        throw new Error("Preview token is no longer valid. Re-run load_csv_dnc_entries preview before confirming.");
+    }
+    return envelope.payload;
+}
+function buildDncPreview(params) {
+    const source = resolveSource(params.input);
+    const name = params.tokenPayload?.name ?? normalizeListName(params.input.name);
+    const warnings = [];
+    const blockingErrors = [];
+    let headers = [];
+    let domainColumn = params.tokenPayload?.domainColumn ?? null;
+    let linkedInColumn = params.tokenPayload?.linkedInColumn ?? null;
+    let candidateDomainColumns = [];
+    let candidateLinkedInColumns = [];
+    let candidates = [];
+    let invalidRows = [];
+    let totalRows = 0;
+    if (source.kind === "rawText") {
+        const parsed = parseRawDncValues(source.content);
+        candidates = parsed.candidates;
+        invalidRows = parsed.invalidRows;
+        totalRows = parsed.totalRows;
+    }
+    else {
+        const parsed = parseCsvRows(source.content);
+        headers = parsed.headers;
+        blockingErrors.push(...parsed.blockingErrors);
+        totalRows = parsed.rows.length;
+        if (blockingErrors.length === 0) {
+            if (!params.tokenPayload) {
+                const detected = detectColumns({
+                    headers,
+                    domainColumn: params.input.domainColumn,
+                    linkedInColumn: params.input.linkedInColumn,
+                });
+                domainColumn = detected.domainColumn;
+                linkedInColumn = detected.linkedInColumn;
+                candidateDomainColumns = detected.candidateDomainColumns;
+                candidateLinkedInColumns = detected.candidateLinkedInColumns;
+                warnings.push(...detected.warnings);
+                blockingErrors.push(...detected.blockingErrors);
+            }
+            else {
+                candidateDomainColumns = matchingColumns(headers, "domain");
+                candidateLinkedInColumns = matchingColumns(headers, "linkedin");
+                if (domainColumn &&
+                    resolveHeaderSelection(headers, domainColumn) !== domainColumn) {
+                    blockingErrors.push("domainColumn changed after preview. Re-run load_csv_dnc_entries preview.");
+                }
+                if (linkedInColumn &&
+                    resolveHeaderSelection(headers, linkedInColumn) !== linkedInColumn) {
+                    blockingErrors.push("linkedInColumn changed after preview. Re-run load_csv_dnc_entries preview.");
+                }
+            }
+        }
+        if (blockingErrors.length === 0) {
+            parsed.rows.forEach((row, index) => {
+                if (domainColumn) {
+                    addDomainCandidate({
+                        candidates,
+                        invalidRows,
+                        value: row[domainColumn] ?? "",
+                        row: index + 2,
+                        column: domainColumn,
+                    });
+                }
+                if (linkedInColumn) {
+                    addLinkedInCandidate({
+                        candidates,
+                        invalidRows,
+                        value: row[linkedInColumn] ?? "",
+                        row: index + 2,
+                        column: linkedInColumn,
+                    });
+                }
+            });
+        }
+    }
+    if (candidates.length > MAX_DNC_CANDIDATES) {
+        warnings.push(`DNC import contained more than ${MAX_DNC_CANDIDATES} valid candidates; only the first ${MAX_DNC_CANDIDATES} will be confirmed.`);
+        candidates = candidates.slice(0, MAX_DNC_CANDIDATES);
+    }
+    const { deduped, duplicateCount } = dedupeCandidates(candidates);
+    const domainCount = deduped.filter((entry) => entry.type === "domain").length;
+    const linkedInCount = deduped.filter((entry) => entry.type === "linkedin").length;
+    if (deduped.length === 0 && blockingErrors.length === 0) {
+        blockingErrors.push("No valid DNC entries were found. Provide domains or LinkedIn profile URLs before confirming.");
+    }
+    const entryHashes = deduped.map(hashEntry);
+    const tokenPayload = blockingErrors.length === 0
+        ? {
+            version: CONFIRMATION_TOKEN_VERSION,
+            sourceKind: source.kind,
+            ...(source.kind === "file"
+                ? {
+                    resolvedFilePath: source.resolvedFilePath,
+                    fileSizeBytes: source.fileSizeBytes,
+                    fileMtimeMs: source.fileMtimeMs,
+                }
+                : {}),
+            contentHash: source.contentHash,
+            workspaceId: params.workspace.id,
+            workspaceName: params.workspace.name,
+            name,
+            domainColumn,
+            linkedInColumn,
+            entryHashes,
+        }
+        : null;
+    return {
+        preview: {
+            workspaceId: params.workspace.id,
+            workspaceName: params.workspace.name,
+            name,
+            sourceKind: source.kind,
+            resolvedFilePath: source.kind === "file" ? source.resolvedFilePath : null,
+            headers,
+            detectedDomainColumn: domainColumn,
+            detectedLinkedInColumn: linkedInColumn,
+            candidateDomainColumns,
+            candidateLinkedInColumns,
+            totalRows,
+            validCount: deduped.length,
+            domainCount,
+            linkedInCount,
+            invalidRowCount: invalidRows.length,
+            duplicateInputCount: duplicateCount,
+            duplicatePolicy: "first_wins",
+            invalidRows: invalidRows.slice(0, 50),
+            warnings,
+            blockingErrors,
+            confirmationToken: tokenPayload ? makeConfirmationToken(tokenPayload) : null,
+        },
+        entries: deduped.map((entry) => ({
+            type: entry.type,
+            value: entry.value,
+        })),
+        source,
+        tokenPayload,
+    };
+}
+function assertTokenMatchesCurrentPreview(tokenPayload, currentPayload) {
+    if (!currentPayload) {
+        throw new Error("DNC preview is no longer actionable. Re-run load_csv_dnc_entries preview before confirming.");
+    }
+    if (tokenPayload.sourceKind !== currentPayload.sourceKind ||
+        tokenPayload.resolvedFilePath !== currentPayload.resolvedFilePath ||
+        tokenPayload.fileSizeBytes !== currentPayload.fileSizeBytes ||
+        tokenPayload.fileMtimeMs !== currentPayload.fileMtimeMs ||
+        tokenPayload.contentHash !== currentPayload.contentHash ||
+        tokenPayload.domainColumn !== currentPayload.domainColumn ||
+        tokenPayload.linkedInColumn !== currentPayload.linkedInColumn ||
+        tokenPayload.name !== currentPayload.name ||
+        !compareStringArrays(tokenPayload.entryHashes, currentPayload.entryHashes)) {
+        throw new Error("DNC import source changed after preview. Re-run load_csv_dnc_entries preview before confirming.");
+    }
+}
+function summarizeDncListResponse(response) {
+    const errors = Array.isArray(response.errors) ? response.errors : [];
+    const duplicateErrors = errors.filter((error) => String(error.error ?? "").toLowerCase().includes("already exists"));
+    const nonDuplicateErrors = errors.filter((error) => !duplicateErrors.includes(error));
+    return {
+        createdCount: typeof response.created === "number" ? response.created : 0,
+        duplicateExistingCount: duplicateErrors.length,
+        backendErrorCount: nonDuplicateErrors.length,
+        backendErrors: nonDuplicateErrors,
+    };
+}
+async function runDncSpotChecks(entries) {
+    const api = getApi();
+    const checks = [];
+    const domain = entries.find((entry) => entry.type === "domain");
+    const linkedin = entries.find((entry) => entry.type === "linkedin");
+    const targets = [domain, linkedin].filter(Boolean);
+    for (const target of targets) {
+        const response = await api.post("/api/v3/dnc-check", {
+            ...(target.type === "domain" ? { domain: target.value } : {}),
+            ...(target.type === "linkedin" ? { linkedinUrl: target.value } : {}),
+        });
+        checks.push({
+            type: target.type,
+            value: target.value,
+            ok: response.isDNC === true,
+            reason: response.reason,
+            matchedValue: response.matchedValue,
+        });
+    }
+    const failed = checks.filter((check) => !check.ok);
+    if (failed.length > 0) {
+        throw new Error(`DNC import wrote entries but dnc-check did not confirm ${failed
+            .map((check) => `${check.type}:${check.value}`)
+            .join(", ")}.`);
+    }
+    return checks;
+}
+export async function loadCsvDncEntries(input) {
+    const workspace = await getVerifiedActiveWorkspace();
+    const api = getApi();
+    if (input.confirmed) {
+        if (!input.confirmationToken) {
+            throw new Error("load_csv_dnc_entries confirmed execution requires confirmationToken from a preview response.");
+        }
+        const tokenPayload = parseConfirmationToken(input.confirmationToken);
+        if (workspace.id !== tokenPayload.workspaceId) {
+            throw new Error(`Active workspace changed after preview. Preview targeted ${tokenPayload.workspaceName} (${tokenPayload.workspaceId}); current active workspace is ${workspace.name} (${workspace.id}). Re-run load_csv_dnc_entries preview for the intended workspace before confirming.`);
+        }
+        const current = buildDncPreview({
+            input: {
+                ...input,
+                name: tokenPayload.name,
+                domainColumn: tokenPayload.domainColumn ?? undefined,
+                linkedInColumn: tokenPayload.linkedInColumn ?? undefined,
+                confirmed: false,
+                confirmationToken: undefined,
+            },
+            workspace,
+            tokenPayload,
+        });
+        assertTokenMatchesCurrentPreview(tokenPayload, current.tokenPayload);
+        const response = await api.post("/api/v3/dnc-list", {
+            name: tokenPayload.name,
+            entries: current.entries,
+        });
+        const summary = summarizeDncListResponse(response);
+        if (summary.backendErrorCount > 0) {
+            return {
+                ok: false,
+                requiresConfirmation: false,
+                workspaceId: workspace.id,
+                workspaceName: workspace.name,
+                name: tokenPayload.name,
+                attemptedCount: current.entries.length,
+                ...summary,
+                guidance: "Sellable DNC import partially failed in the existing DNC endpoint. Review backendErrors and re-run preview after fixing the input.",
+            };
+        }
+        const spotChecks = await runDncSpotChecks(current.entries);
+        const ok = summary.createdCount > 0 || summary.duplicateExistingCount > 0;
+        return {
+            ok,
+            requiresConfirmation: false,
+            workspaceId: workspace.id,
+            workspaceName: workspace.name,
+            name: tokenPayload.name,
+            attemptedCount: current.entries.length,
+            ...summary,
+            spotChecks,
+            guidance: summary.createdCount > 0
+                ? `Added entries to Sellable's DNC list for workspace ${workspace.name} (${workspace.id}). Campaign creation already includes a DNC Check column that checks domain/profile before message generation.`
+                : `No new entries were created because the valid entries are already in Sellable's DNC list for workspace ${workspace.name} (${workspace.id}). Campaign creation already includes a DNC Check column that checks domain/profile before message generation.`,
+        };
+    }
+    const built = buildDncPreview({ input, workspace });
+    if (!built.preview.confirmationToken) {
+        return {
+            ok: false,
+            requiresConfirmation: false,
+            preview: built.preview,
+            suggestedToolCalls: [],
+        };
+    }
+    return {
+        ok: true,
+        requiresConfirmation: true,
+        preview: built.preview,
+        confirmationToken: built.preview.confirmationToken,
+        suggestedToolCalls: [
+            {
+                tool: "load_csv_dnc_entries",
+                args: {
+                    ...(input.filePath ? { filePath: input.filePath } : {}),
+                    ...(input.csvText ? { csvText: input.csvText } : {}),
+                    ...(input.rawText ? { rawText: input.rawText } : {}),
+                    ...(input.name ? { name: input.name } : {}),
+                    ...(built.preview.detectedDomainColumn
+                        ? { domainColumn: built.preview.detectedDomainColumn }
+                        : {}),
+                    ...(built.preview.detectedLinkedInColumn
+                        ? { linkedInColumn: built.preview.detectedLinkedInColumn }
+                        : {}),
+                    confirmed: true,
+                    confirmationToken: built.preview.confirmationToken,
+                },
+            },
+        ],
+        guidance: `I will add this to Sellable's DNC list for workspace ${workspace.name} (${workspace.id}). Campaign creation already includes a DNC Check column that checks domain/profile before message generation. Confirm before writing.`,
+    };
+}

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

@@ -64,6 +64,13 @@ type ParsedCsvDomainFile = {
     blockingErrors: string[];
     warnings: string[];
 };
+export declare function sanitizeCsvDomainCandidate(value: unknown): {
+    valid: true;
+    cleaned: string;
+} | {
+    valid: false;
+    reason: string;
+};
 export declare function makeConfirmationToken(payload: CsvDomainConfirmationPayload): string;
 export declare function parseConfirmationToken(token: string): CsvDomainConfirmationPayload;
 export declare function matchesConfirmationToken(token: string, payload: CsvDomainConfirmationPayload): boolean;

package/dist/tools/csv-domains.js

@@ -70,7 +70,7 @@ function resolveCsvDomainPath(filePath, workspaceRoot = defaultWorkspaceRoot) {
         ? resolve(filePath)
         : resolve(workspaceRoot, filePath);
 }
-function sanitizeCsvDomainCandidate(value) {
+export function sanitizeCsvDomainCandidate(value) {
     let cleaned = String(value ?? "")
         .trim()
         .toLowerCase();

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

@@ -79,6 +79,14 @@ type ParsedCsvLinkedinFile = {
     blockingErrors: string[];
     warnings: string[];
 };
+export type LinkedInValidationResult = {
+    valid: true;
+    normalizedUrl: string;
+} | {
+    valid: false;
+    reason: string;
+};
+export declare function validateAndNormalizeLinkedInUrl(value: string): LinkedInValidationResult;
 export declare function makeLinkedinConfirmationToken(payload: CsvLinkedinConfirmationPayload): string;
 export declare function parseLinkedinConfirmationToken(token: string): CsvLinkedinConfirmationPayload;
 export declare function matchesLinkedinConfirmationToken(token: string, payload: CsvLinkedinConfirmationPayload): boolean;