@sellable/mcp 0.1.365 → 0.1.366

package/dist/tools/workspace-export.js

@@ -0,0 +1,465 @@
+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. " +
+            "Use exportIntent to disambiguate counts before exporting: " +
+            "`reached_out_people` means one deduped row per unique prospect who received an actual contact attempt (invite, DM, open InMail, or paid/closed InMail) and is the right choice for 'everyone we reached out to'; " +
+            "`dashboard_messages` means message events only (DMs + InMails), matching the dashboard Messages Sent card; " +
+            "`connections_sent` means invite events only; " +
+            "`outreach_event_log` means one row per action event for audit/reconciliation; " +
+            "`people_and_events` exports the reached-out people CSV plus matching contact event rows. " +
+            "If the user asks for 'sent', 'reached out', or cites conflicting dashboard/export numbers, ask which intent they want before calling the tool. " +
+            "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.",
+                },
+                exportIntent: {
+                    type: "string",
+                    enum: [
+                        "reached_out_people",
+                        "people_and_events",
+                        "outreach_event_log",
+                        "dashboard_messages",
+                        "connections_sent",
+                    ],
+                    description: "Recommended semantic export. Use reached_out_people for 'everyone we reached out to'; dashboard_messages for the dashboard Messages Sent card; connections_sent for invites; outreach_event_log for audit rows; people_and_events for both reached people and matching contact events.",
+                },
+                datasets: {
+                    type: "array",
+                    items: { type: "string", enum: ["people", "events"] },
+                    description: "Low-level datasets to export. people is one deduped prospect row; events is one action row. Omit this and use exportIntent for clearer behavior.",
+                },
+                actionTypes: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: [
+                            "INVITE",
+                            "DM",
+                            "INMAIL_OPEN",
+                            "INMAIL_CLOSED",
+                            "VIEW_PROFILE",
+                            "COMMENT",
+                        ],
+                    },
+                    description: "Optional low-level action filter. Usually omit and use exportIntent. Dashboard messages are DM + INMAIL_OPEN + INMAIL_CLOSED; reached-out/contact events are INVITE + DM + INMAIL_OPEN + INMAIL_CLOSED.",
+                },
+                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,
+        },
+    },
+];
+const CONTACT_ACTION_TYPES = [
+    "INVITE",
+    "DM",
+    "INMAIL_OPEN",
+    "INMAIL_CLOSED",
+];
+const DASHBOARD_MESSAGE_ACTION_TYPES = [
+    "DM",
+    "INMAIL_OPEN",
+    "INMAIL_CLOSED",
+];
+const ALL_ACTION_TYPES = [
+    "INVITE",
+    "DM",
+    "INMAIL_OPEN",
+    "INMAIL_CLOSED",
+    "VIEW_PROFILE",
+    "COMMENT",
+];
+const EXPORT_INTENT_CONFIG = {
+    reached_out_people: {
+        datasets: ["people"],
+        actionTypes: CONTACT_ACTION_TYPES,
+        description: "Unique prospects who received at least one actual contact attempt: invite, DM, open InMail, or paid/closed InMail.",
+    },
+    people_and_events: {
+        datasets: ["people", "events"],
+        actionTypes: CONTACT_ACTION_TYPES,
+        description: "Reached-out people plus one matching contact event row per invite, DM, open InMail, or paid/closed InMail.",
+    },
+    outreach_event_log: {
+        datasets: ["events"],
+        actionTypes: ALL_ACTION_TYPES,
+        description: "Raw workflow-table-backed action event log for audit/reconciliation, including profile views and comments when present.",
+    },
+    dashboard_messages: {
+        datasets: ["events"],
+        actionTypes: DASHBOARD_MESSAGE_ACTION_TYPES,
+        description: "Message events only, matching the dashboard Messages Sent card: DMs + open InMails + paid/closed InMails.",
+    },
+    connections_sent: {
+        datasets: ["events"],
+        actionTypes: ["INVITE"],
+        description: "Connection invite events only, matching the dashboard Connections Sent sub-count.",
+    },
+};
+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 normalizeExportIntent(value) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (value !== "reached_out_people" &&
+        value !== "people_and_events" &&
+        value !== "outreach_event_log" &&
+        value !== "dashboard_messages" &&
+        value !== "connections_sent") {
+        throw new Error("exportIntent is not supported");
+    }
+    return value;
+}
+function normalizeActionTypes(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error("actionTypes must be an array");
+    if (value.length === 0)
+        throw new Error("actionTypes cannot be empty");
+    const unique = Array.from(new Set(value));
+    return unique.map((actionType) => {
+        if (actionType !== "INVITE" &&
+            actionType !== "DM" &&
+            actionType !== "INMAIL_OPEN" &&
+            actionType !== "INMAIL_CLOSED" &&
+            actionType !== "VIEW_PROFILE" &&
+            actionType !== "COMMENT") {
+            throw new Error("actionTypes contains an unsupported action type");
+        }
+        return actionType;
+    });
+}
+function validateInput(input) {
+    if (input.exportType && input.exportType !== "outreach") {
+        throw new Error("exportType must be outreach");
+    }
+    const exportIntent = normalizeExportIntent(input.exportIntent);
+    const intentConfig = exportIntent ? EXPORT_INTENT_CONFIG[exportIntent] : null;
+    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");
+    }
+    const actionTypes = normalizeActionTypes(input.actionTypes);
+    return {
+        exportIntent,
+        intentDescription: intentConfig?.description ?? null,
+        datasets: input.datasets === undefined || input.datasets === null
+            ? (intentConfig?.datasets ?? ["people", "events"])
+            : normalizeDatasets(input.datasets),
+        actionTypes: actionTypes.length > 0 ? actionTypes : (intentConfig?.actionTypes ?? []),
+        outputDir: input.outputDir,
+        fromSentAt,
+        toSentAt,
+        campaignIds: assertIdList(input.campaignIds, "campaignIds"),
+        tableIds: assertIdList(input.tableIds, "tableIds"),
+    };
+}
+function countDefinitions() {
+    return {
+        reachedOutPeople: "Deduped prospects with at least one actual contact attempt: INVITE, DM, INMAIL_OPEN, or INMAIL_CLOSED. This is what 'everyone we reached out to' should mean.",
+        outreachEvents: "One row per exported LinkedInOutreach action event after workspace, date, campaign/table, and action-type filters.",
+        dashboardMessagesSent: "Dashboard Messages Sent equals DM + INMAIL_OPEN + INMAIL_CLOSED events. It excludes connection invites.",
+        connectionsSent: "Dashboard Connections Sent equals INVITE events. Accepted invites show separately as Connections Made.",
+        profileViews: "VIEW_PROFILE is an action event for audit logs, but it is not a contact attempt and should not define reached-out people.",
+    };
+}
+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,
+        actionTypes: validated.actionTypes,
+    });
+    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,
+            actionTypes: validated.actionTypes,
+        });
+        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",
+        exportIntent: validated.exportIntent ?? "legacy_datasets",
+        intentDescription: validated.intentDescription,
+        countDefinitions: countDefinitions(),
+        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,
+            actionTypes: validated.actionTypes,
+            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,
+        exportIntent: validated.exportIntent ?? null,
+        intentDescription: validated.intentDescription,
+        countDefinitions: countDefinitions(),
+        counts: backendMetadata.counts ?? {},
+        workspace: backendMetadata.workspace ?? {
+            id: workspaceId,
+            name: config.activeWorkspaceName || config.workspaceName || null,
+        },
+        skipped: backendMetadata.skipped ?? [],
+        failures,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.365",
+  "version": "0.1.366",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/create-campaign/SKILL.md

@@ -142,14 +142,6 @@ Treat active fills as capacity-fill preparation: calculate the bounded target
 from sender capacity when needed, then use the refill workflow to decide source
 replenishment, enrichment/prep, approval policy, and scheduler proof. Mutation
 requires exact visible approval and a fresh `get_campaign_refill_state` reread.
-For already-running regular campaigns that need Signal Discovery source
-replenishment, the refill workflow owns the guarded recovery: clear
-`currentStep` only with `clearCurrentStepIfMatches:"running"`, load the
-campaign-scoped provider prompt, run campaign-scoped `search_signals`, select
-posts with a capacity-target scrape plan, import into the same source path, and
-restore Running through `confirm_lead_list`. If the copied rows append beyond
-the first table page, inspect `reviewBatch` with table-schema/selector tools and
-use adaptive or wider bounded message prep; do not rely on a fixed `maxRowsToCheck:100` pass after source copy.
 If the user says "prepare/generate X messages", use message-prep primitives with
 `targetPreparedMessages:X` and default `approvalMode:"mark_ready"`. If the user
 says "approve X messages", use `approvalMode:"approve"` only for the bounded

package/skills/create-campaign-v2/references/final-handoff-contract.md

@@ -63,15 +63,6 @@ currentStep: "sequence" })` to attach the sender via the v3 senders route and
    and Paid InMail Campaign is only an explicit paid-InMail opt-in because it
    can spend InMail credits. If that response does not persist `currentStep:
 "send"`, call `update_campaign({ campaignId, currentStep: "send" })`.
-   Then reread `get_campaign({ campaignId })` and `list_tables()` and verify the
-   current `workflowTableId` has `hasSequence:true`. A campaign-level
-   `SEQUENCE_EXISTS` response is not enough when `confirm_lead_list` or another
-   copy step has moved the campaign to a new current campaign table while an old
-   stale shell table still owns the sequence columns. In that stale-shell case,
-   either repair only the current workflowTableId with `attach_sequence` using
-   the same non-paid product template the recommended selector would have chosen,
-   or stop and report the stale-shell sequence blocker if replacement was not
-   explicitly approved. Never choose a paid-InMail template for this repair.
 9. Surface the `handoff.orientation` string from `auto-execute.yaml` and
    summarize the visible Settings/Sequence/Send state without repeating the
    watch URL.
@@ -150,11 +141,7 @@ order, atomically:
 2. **Validate sender + sequence state.** If no sender is attached, refuse start
    and return the Settings link. If no sequence is attached but a sender is
    attached, call `attach_recommended_sequence({ campaignId, currentStep:
-"send" })` before approving messages, then rerun the precondition check against
-   the current workflowTableId rather than an older shell table. If
-   `SEQUENCE_EXISTS` only proves an old shell while the current table lacks
-   `hasSequence:true`, stop or perform the explicitly approved stale-shell
-   current-table repair before any launch.
+"send" })` before approving messages.
 3. **Approve generated messages** through the bounded or broad path:
    - If the user asked for an exact send count, such as "schedule 250 sends",
      verify the preparation job approved only the bounded prepared cohort for

package/skills/create-campaign-v2-tail/SKILL.md

@@ -68,7 +68,6 @@ Step 16 — awaiting-user-greenlight
   ask the user which connected sender to attach; in explicit UAT safe mode only, use the safe mock sender
   update_campaign(senderIds=[selectedSenderId], currentStep=sequence)
   attach_recommended_sequence({ campaignId, currentStep: "send" })  # tier-aware: premium/SN -> If Open Profile->INMAIL_OPEN, else INVITE->accepted->DM
-  reread get_campaign + list_tables; verify hasSequence:true on the current workflowTableId, not an older shell table
   if the attach response did not move the UI: update_campaign(currentStep=send)
   surface campaign setup orientation + final launch choices without repeating the watch URL
   STOP. DO NOT call start_campaign. DO NOT move to running without explicit launch greenlight.
@@ -82,13 +81,7 @@ hand-author a `version: 2` template with nodes, branches, and
 entryNodeId — that's error-prone mid-long-context (galley-off UAT
 `20260420T195732Z` failed because Claude hit "Invalid node type" and
 tried to debug via forbidden Bash/Glob calls). Use `attach_sequence`
-only when the caller explicitly needs a custom non-recommended cadence, or when
-you have just reread the campaign after `confirm_lead_list` and proved the
-current campaign table has no sequence while an older stale shell table is
-causing campaign-level `SEQUENCE_EXISTS`. In that stale-shell repair case, use
-`attach_sequence` on the current workflowTableId with the same non-paid product
-template the backend would select; never choose a paid-InMail template and never
-repair a table other than the current workflowTableId.
+only when the caller explicitly needs a custom non-recommended cadence.
 
 Hard gates — if you find yourself about to violate any of these, stop
 first:
@@ -539,14 +532,6 @@ Shape:
    opt-in because it can spend InMail credits. If the tool response
    does not persist `currentStep: "send"`, call
    `update_campaign({ campaignId, currentStep: "send" })`.
-   Then reread `get_campaign({ campaignId })` and `list_tables()` and verify the
-   returned current workflowTableId has `hasSequence:true`. If
-   `attach_recommended_sequence` returned `SEQUENCE_EXISTS` but the current table
-   still has `hasSequence:false`, do not continue to launch handoff from that
-   stale shell proof. Repair only the current workflowTableId with
-   `attach_sequence` using the same non-paid product template the recommended
-   selector would have chosen, or stop and report the stale-shell sequence
-   blocker if replacement was not explicitly approved.
 9. Surface the `handoff.orientation` string from `auto-execute.yaml` without
    repeating the watch URL.
 10. Ask the final launch greenlight with the structured question function: