@sellable/mcp 0.1.363 → 0.1.365

package/dist/tools/workspace-export.d.ts

@@ -1,82 +0,0 @@
-export type WorkspaceExportDataset = "people" | "events";
-export interface ExportWorkspaceCsvInput {
-    exportType?: "outreach";
-    datasets?: WorkspaceExportDataset[];
-    outputDir?: string;
-    fromSentAt?: string;
-    toSentAt?: string;
-    campaignIds?: string[];
-    tableIds?: string[];
-}
-export declare const workspaceExportToolDefinitions: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            exportType: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            datasets: {
-                type: string;
-                items: {
-                    type: string;
-                    enum: string[];
-                };
-                description: string;
-            };
-            outputDir: {
-                type: string;
-                description: string;
-            };
-            fromSentAt: {
-                type: string;
-                description: string;
-            };
-            toSentAt: {
-                type: string;
-                description: string;
-            };
-            campaignIds: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            tableIds: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-        };
-        required: never[];
-        additionalProperties: boolean;
-    };
-}[];
-export declare function exportWorkspaceCsv(input?: ExportWorkspaceCsvInput): Promise<{
-    status: string;
-    outputDir: string;
-    manifestPath: string;
-    datasets: {
-        dataset: WorkspaceExportDataset;
-        path: string;
-        rows: number;
-        bytes: number;
-        status: "complete" | "failed";
-    }[];
-    exportCutoff: string;
-    workspace: {
-        id?: string;
-        name?: string | null;
-    };
-    skipped: string[];
-    failures: {
-        dataset: WorkspaceExportDataset;
-        error: string;
-    }[];
-}>;

package/dist/tools/workspace-export.js

@@ -1,328 +0,0 @@
-import { parse } from "csv-parse";
-import { createReadStream } from "node:fs";
-import { lstat, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { getApi } from "../api.js";
-import { getConfig } from "../auth.js";
-const MAX_FILTER_IDS = 100;
-const MAX_QUERY_LENGTH = 8000;
-export const workspaceExportToolDefinitions = [
-    {
-        name: "export_workspace_csv",
-        description: "Export active-workspace outreach CSVs to local files on the MCP host. " +
-            "Phase 70 supports workflow-table-backed reached-out people and event-level outreach only. " +
-            "Requires a valid Sellable API key plus active workspace; run list_workspaces and set_active_workspace first if needed. " +
-            "The manifest includes file paths, counts, filters, package/runtime metadata, and skipped/deferred scope notes. " +
-            "CSV files may contain prospect and outreach metadata, so store them appropriately.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                exportType: {
-                    type: "string",
-                    enum: ["outreach"],
-                    description: "Export family. Phase 70 supports outreach only.",
-                },
-                datasets: {
-                    type: "array",
-                    items: { type: "string", enum: ["people", "events"] },
-                    description: "Datasets to export. Defaults to both people and events.",
-                },
-                outputDir: {
-                    type: "string",
-                    description: "Optional base directory. A unique run subdirectory is created inside it.",
-                },
-                fromSentAt: {
-                    type: "string",
-                    description: "Optional ISO lower bound for outreach sentAt.",
-                },
-                toSentAt: {
-                    type: "string",
-                    description: "Optional ISO upper bound for outreach sentAt.",
-                },
-                campaignIds: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Optional campaign ids to include, max 100.",
-                },
-                tableIds: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Optional workflow table ids to include, max 100.",
-                },
-            },
-            required: [],
-            additionalProperties: false,
-        },
-    },
-];
-function assertIsoDate(value, field) {
-    if (value === undefined || value === null || value === "")
-        return undefined;
-    if (typeof value !== "string")
-        throw new Error(`${field} must be a string`);
-    const date = new Date(value);
-    if (!Number.isFinite(date.getTime())) {
-        throw new Error(`${field} must be a valid ISO date`);
-    }
-    return date.toISOString();
-}
-function assertIdList(value, field) {
-    if (value === undefined || value === null)
-        return [];
-    if (!Array.isArray(value))
-        throw new Error(`${field} must be an array`);
-    if (value.length > MAX_FILTER_IDS) {
-        throw new Error(`${field} supports at most ${MAX_FILTER_IDS} ids`);
-    }
-    return value.map((id) => {
-        if (typeof id !== "string" || !/^[A-Za-z0-9_.:-]+$/.test(id)) {
-            throw new Error(`${field} contains an invalid id`);
-        }
-        return id;
-    });
-}
-function normalizeDatasets(value) {
-    if (value === undefined || value === null)
-        return ["people", "events"];
-    if (!Array.isArray(value))
-        throw new Error("datasets must be an array");
-    if (value.length === 0)
-        throw new Error("datasets cannot be empty");
-    const unique = Array.from(new Set(value));
-    return unique.map((dataset) => {
-        if (dataset !== "people" && dataset !== "events") {
-            throw new Error("datasets may only contain people or events");
-        }
-        return dataset;
-    });
-}
-function validateInput(input) {
-    if (input.exportType && input.exportType !== "outreach") {
-        throw new Error("exportType must be outreach");
-    }
-    const fromSentAt = assertIsoDate(input.fromSentAt, "fromSentAt");
-    const toSentAt = assertIsoDate(input.toSentAt, "toSentAt");
-    if (fromSentAt && toSentAt && new Date(fromSentAt) > new Date(toSentAt)) {
-        throw new Error("fromSentAt must be before toSentAt");
-    }
-    return {
-        datasets: normalizeDatasets(input.datasets),
-        outputDir: input.outputDir,
-        fromSentAt,
-        toSentAt,
-        campaignIds: assertIdList(input.campaignIds, "campaignIds"),
-        tableIds: assertIdList(input.tableIds, "tableIds"),
-    };
-}
-async function packageVersion() {
-    const entryDir = process.argv[1]
-        ? path.dirname(path.resolve(process.argv[1]))
-        : process.cwd();
-    const candidates = [
-        path.resolve(process.cwd(), "mcp/sellable/package.json"),
-        path.resolve(entryDir, "../package.json"),
-        path.resolve(entryDir, "../../package.json"),
-    ];
-    for (const candidate of candidates) {
-        try {
-            const raw = await readFile(candidate, "utf8");
-            const parsed = JSON.parse(raw);
-            if (typeof parsed.version === "string")
-                return parsed.version;
-        }
-        catch {
-            // Try the next runtime/package layout.
-        }
-    }
-    return null;
-}
-async function ensureSafeBaseDir(outputDir) {
-    const baseDir = path.resolve(outputDir || path.join(tmpdir(), "sellable-mcp-exports"));
-    await mkdir(baseDir, { recursive: true });
-    const baseStat = await lstat(baseDir);
-    if (baseStat.isSymbolicLink()) {
-        throw new Error("outputDir must not be a symlink");
-    }
-    if (!baseStat.isDirectory()) {
-        throw new Error("outputDir must be a directory");
-    }
-    return baseDir;
-}
-async function createRunDir(outputDir) {
-    const baseDir = await ensureSafeBaseDir(outputDir);
-    for (let attempt = 0; attempt < 10; attempt++) {
-        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const runDir = path.join(baseDir, `workspace-outreach-${stamp}-${process.pid}-${attempt}`);
-        try {
-            await mkdir(runDir, { recursive: false });
-            return runDir;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-        }
-    }
-    throw new Error("Failed to create unique export directory");
-}
-function buildQuery(params) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-        if (Array.isArray(value)) {
-            if (value.length > 0)
-                searchParams.set(key, value.join(","));
-        }
-        else if (value) {
-            searchParams.set(key, value);
-        }
-    }
-    const query = searchParams.toString();
-    if (query.length > MAX_QUERY_LENGTH) {
-        throw new Error("Export query string is too long");
-    }
-    return query ? `?${query}` : "";
-}
-async function countCsvRows(filePath) {
-    const parser = createReadStream(filePath).pipe(parse({ bom: true, relax_column_count: true }));
-    let records = 0;
-    for await (const _record of parser) {
-        records += 1;
-    }
-    return Math.max(0, records - 1);
-}
-function redactManifest(value) {
-    if (Array.isArray(value))
-        return value.map(redactManifest);
-    if (!value || typeof value !== "object")
-        return value;
-    const entries = Object.entries(value).map(([key, entry]) => {
-        if (/token|secret|authorization|api[_-]?key/i.test(key)) {
-            return [key, "[redacted]"];
-        }
-        return [key, redactManifest(entry)];
-    });
-    return Object.fromEntries(entries);
-}
-async function writeJsonAtomic(filePath, value) {
-    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, {
-        encoding: "utf8",
-        flag: "wx",
-    });
-    await rename(tempPath, filePath);
-}
-export async function exportWorkspaceCsv(input = {}) {
-    const config = getConfig();
-    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
-    if (!workspaceId) {
-        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before export_workspace_csv.");
-    }
-    const validated = validateInput(input);
-    const startedAt = new Date().toISOString();
-    const runDir = await createRunDir(validated.outputDir);
-    const api = getApi();
-    const metadataQuery = buildQuery({
-        fromSentAt: validated.fromSentAt,
-        toSentAt: validated.toSentAt,
-        campaignIds: validated.campaignIds,
-        tableIds: validated.tableIds,
-    });
-    const metadataEndpoint = `/api/v3/mcp/workspace-export/outreach/metadata${metadataQuery}`;
-    const backendMetadata = await api.get(metadataEndpoint);
-    const exportCutoff = backendMetadata.exportCutoff;
-    if (!exportCutoff) {
-        throw new Error("Export metadata did not include exportCutoff");
-    }
-    const files = [];
-    const failures = [];
-    for (const dataset of validated.datasets) {
-        const query = buildQuery({
-            dataset,
-            exportCutoff,
-            fromSentAt: validated.fromSentAt,
-            toSentAt: validated.toSentAt,
-            campaignIds: validated.campaignIds,
-            tableIds: validated.tableIds,
-        });
-        const endpoint = `/api/v3/mcp/workspace-export/outreach${query}`;
-        const filePath = path.join(runDir, `outreach-${dataset}.csv`);
-        try {
-            const download = await api.downloadToFile(endpoint, filePath);
-            files.push({
-                dataset,
-                path: download.path,
-                rows: await countCsvRows(download.path),
-                bytes: download.bytes,
-                endpoint,
-                contentType: download.contentType,
-                status: "complete",
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Unknown error";
-            failures.push({ dataset, error: message });
-            files.push({
-                dataset,
-                path: filePath,
-                rows: 0,
-                bytes: 0,
-                endpoint,
-                contentType: null,
-                status: "failed",
-                error: message,
-            });
-            await rm(filePath, { force: true }).catch(() => undefined);
-        }
-    }
-    const manifest = redactManifest({
-        status: failures.length > 0 ? "partial" : "success",
-        tool: "export_workspace_csv",
-        exportType: "outreach",
-        startedAt,
-        completedAt: new Date().toISOString(),
-        package: {
-            name: "@sellable/mcp",
-            version: await packageVersion(),
-        },
-        config: {
-            apiUrl: config.apiUrl,
-            activeWorkspaceId: workspaceId,
-            activeWorkspaceName: config.activeWorkspaceName || config.workspaceName,
-        },
-        backend: {
-            metadataEndpoint,
-            metadata: backendMetadata,
-        },
-        filters: {
-            fromSentAt: validated.fromSentAt ?? null,
-            toSentAt: validated.toSentAt ?? null,
-            campaignIds: validated.campaignIds,
-            tableIds: validated.tableIds,
-            exportCutoff,
-        },
-        outputDir: runDir,
-        files,
-        failures,
-    });
-    const manifestPath = path.join(runDir, "manifest.json");
-    await writeJsonAtomic(manifestPath, manifest);
-    return {
-        status: failures.length > 0 ? "partial" : "success",
-        outputDir: runDir,
-        manifestPath,
-        datasets: files.map((file) => ({
-            dataset: file.dataset,
-            path: file.path,
-            rows: file.rows,
-            bytes: file.bytes,
-            status: file.status,
-        })),
-        exportCutoff,
-        workspace: backendMetadata.workspace ?? {
-            id: workspaceId,
-            name: config.activeWorkspaceName || config.workspaceName || null,
-        },
-        skipped: backendMetadata.skipped ?? [],
-        failures,
-    };
-}