@sellable/mcp 0.1.0

package/dist/tools/cells.d.ts

@@ -0,0 +1,58 @@
+export interface UpdateCellResult {
+    success: boolean;
+    cellId: string;
+    isOverridden: boolean;
+}
+export declare const cellToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            cellId: {
+                type: string;
+                description: string;
+            };
+            value: {
+                oneOf: {
+                    type: string;
+                }[];
+                description: string;
+            };
+            tableId?: undefined;
+            cellIds?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+                description: string;
+            };
+            cellIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            cellId?: undefined;
+            value?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function updateCell(cellId: string, value: string | boolean | object): Promise<UpdateCellResult>;
+export interface QueueCellsResult {
+    queued: number;
+    dispatched?: number;
+    failed?: number;
+    skipped?: number;
+    message?: string;
+}
+export declare function queueCells(tableId: string, cellIds: string[]): Promise<QueueCellsResult>;

package/dist/tools/cells.js

@@ -0,0 +1,48 @@
+import { getApi } from "../api.js";
+export const cellToolDefinitions = [
+    {
+        name: "update_cell",
+        description: "Update a cell's value. Use for saving crafted messages (messageCellId/subjectCellId), marking examples (exampleCellId with value: true/false), or approving for send (approveCellId with value: true).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cellId: {
+                    type: "string",
+                    description: "Cell ID (messageCellId/subjectCellId, exampleCellId, or approveCellId from row)",
+                },
+                value: {
+                    oneOf: [{ type: "string" }, { type: "boolean" }, { type: "object" }],
+                    description: "Value to set. String for messages, true for approval.",
+                },
+            },
+            required: ["cellId", "value"],
+        },
+    },
+    {
+        name: "queue_cells",
+        description: "Queue cells for processing (enrichment, ICP scoring, etc). Use with cell IDs from get_rows_minimal (enrichCellId, icpCellId).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: {
+                    type: "string",
+                    description: "Workflow table ID",
+                },
+                cellIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Cell IDs to queue for processing",
+                },
+            },
+            required: ["tableId", "cellIds"],
+        },
+    },
+];
+export async function updateCell(cellId, value) {
+    const api = getApi();
+    return api.patch(`/api/v3/workflow-tables/cells/${cellId}/update-result`, { value });
+}
+export async function queueCells(tableId, cellIds) {
+    const api = getApi();
+    return api.post(`/api/v3/workflow-tables/cells/queue-batch`, { tableId, cellIds });
+}

package/dist/tools/context.d.ts

@@ -0,0 +1,88 @@
+import { getCampaignNavigationState, type CampaignOfferNavigation } from "./navigation.js";
+type GetCampaignContextInput = {
+    campaignId: string;
+    flowVersion?: "v1" | "v2";
+    refresh?: boolean;
+    includeTableCheck?: boolean;
+};
+type FrameworkSnapshot = {
+    flowVersion: string;
+    providerRegistry: unknown;
+    providers: Record<string, unknown>;
+    overrides: Record<string, unknown>;
+    warnings: string[];
+};
+type CampaignContextEntry = {
+    campaignId: string;
+    flowVersion: "v1" | "v2";
+    framework: FrameworkSnapshot;
+    navState: Awaited<ReturnType<typeof getCampaignNavigationState>>;
+    providerConfig: unknown | null;
+    cachedAt: string;
+    dirty: boolean;
+    dirtyReasons: string[];
+};
+export declare function hydrateCampaignContextFromCampaign(campaign: CampaignOfferNavigation, reason: string): CampaignContextEntry;
+export declare function hydrateCampaignContextFromNavigation(navState: Awaited<ReturnType<typeof getCampaignNavigationState>>, reason: string): CampaignContextEntry;
+export declare function markCampaignContextDirty(campaignId: string, reason: string): void;
+export declare const contextToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            flowVersion: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            refresh: {
+                type: string;
+                description: string;
+            };
+            includeTableCheck: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function getCampaignContext(input: GetCampaignContextInput): Promise<{
+    campaignId: string;
+    flowVersion: "v1" | "v2";
+    cachedAt: string;
+    refreshed: boolean;
+    dirty: boolean;
+    dirtyReasons: string[];
+    navigation: {
+        campaignId: string;
+        computedStep: "campaign-created" | "pick-provider" | "provider-search" | "confirm-lead-list";
+        blockedAt: ("campaign-created" | "pick-provider" | "provider-search" | "confirm-lead-list") | null;
+        missing: string[];
+        expectedHeadlessStep: string | null;
+        headlessCurrentStep: string | null;
+        uiStep: string | null;
+        table: {
+            workflowTableId: string | null;
+            checked: boolean;
+            rowCount: number | null;
+            hasRows: boolean | null;
+        };
+        context: {
+            leadSourceType: string | null;
+            leadSourceProvider: string | null;
+            selectedLeadListId: string | null;
+            providerCurrentStep: string | null;
+        };
+        warnings: string[];
+    };
+    providerConfig: unknown;
+    framework: FrameworkSnapshot;
+}>;
+export {};

package/dist/tools/context.js

@@ -0,0 +1,271 @@
+import { getCampaignFramework } from "./framework.js";
+import { computeCampaignNavigationStateFromCampaign, getCampaignNavigationState, logNavigationDebug, } from "./navigation.js";
+const frameworkCache = new Map();
+const campaignContextCache = new Map();
+function frameworkCacheKey(flowVersion) {
+    return `flow:${flowVersion}`;
+}
+function getFrameworkSnapshot(flowVersion, force = false) {
+    const key = frameworkCacheKey(flowVersion);
+    if (!force) {
+        const cached = frameworkCache.get(key);
+        if (cached)
+            return cached;
+    }
+    const framework = getCampaignFramework({
+        flowVersion,
+        includePlugins: true,
+    });
+    const snapshot = {
+        flowVersion: framework.flowVersion,
+        providerRegistry: framework.providerRegistry,
+        providers: framework.providers,
+        overrides: framework.overrides,
+        warnings: framework.warnings,
+    };
+    frameworkCache.set(key, snapshot);
+    return snapshot;
+}
+function deriveProviderConfig(framework, navState) {
+    const providerId = navState.context.leadSourceProvider;
+    if (!providerId)
+        return null;
+    return framework.providers[providerId] ?? null;
+}
+export function hydrateCampaignContextFromCampaign(campaign, reason) {
+    logNavigationDebug("context.hydrate_from_campaign.start", {
+        campaignId: campaign.id,
+        reason,
+        currentStep: campaign.currentStep ?? null,
+        workflowTableId: campaign.workflowTableId ?? null,
+        leadSourceProvider: campaign.leadSourceProvider ?? null,
+    }, campaign.id);
+    const flowVersion = "v1";
+    const framework = getFrameworkSnapshot(flowVersion);
+    const navState = computeCampaignNavigationStateFromCampaign(campaign, {
+        includeTableCheck: false,
+        tableChecked: false,
+        rowCount: null,
+        hasWorkflowRows: null,
+    });
+    const providerConfig = deriveProviderConfig(framework, navState);
+    const entry = {
+        campaignId: campaign.id,
+        flowVersion,
+        framework,
+        navState,
+        providerConfig,
+        cachedAt: new Date().toISOString(),
+        dirty: false,
+        dirtyReasons: [],
+    };
+    campaignContextCache.set(campaign.id, entry);
+    logNavigationDebug("context.hydrate_from_campaign.complete", {
+        campaignId: campaign.id,
+        reason,
+        computedStep: navState.computedStep,
+        blockedAt: navState.blockedAt,
+        missing: navState.missing,
+        providerConfigResolved: Boolean(providerConfig),
+    }, campaign.id);
+    return entry;
+}
+export function hydrateCampaignContextFromNavigation(navState, reason) {
+    logNavigationDebug("context.hydrate_from_navigation.start", {
+        campaignId: navState.campaignId,
+        reason,
+        computedStep: navState.computedStep,
+        blockedAt: navState.blockedAt,
+        missing: navState.missing,
+    }, navState.campaignId);
+    const flowVersion = "v1";
+    const framework = getFrameworkSnapshot(flowVersion);
+    const providerConfig = deriveProviderConfig(framework, navState);
+    const entry = {
+        campaignId: navState.campaignId,
+        flowVersion,
+        framework,
+        navState,
+        providerConfig,
+        cachedAt: new Date().toISOString(),
+        dirty: false,
+        dirtyReasons: [],
+    };
+    campaignContextCache.set(navState.campaignId, entry);
+    logNavigationDebug("context.hydrate_from_navigation.complete", {
+        campaignId: navState.campaignId,
+        reason,
+        providerConfigResolved: Boolean(providerConfig),
+        warnings: navState.warnings,
+    }, navState.campaignId);
+    return entry;
+}
+async function refreshCampaignContext(campaignId, flowVersion, options) {
+    logNavigationDebug("context.refresh.start", {
+        campaignId,
+        flowVersion,
+        forceFramework: options.forceFramework === true,
+        includeTableCheck: options.includeTableCheck,
+    }, campaignId);
+    const framework = getFrameworkSnapshot(flowVersion, options.forceFramework);
+    const navState = await getCampaignNavigationState({
+        campaignId,
+        includeTableCheck: options.includeTableCheck,
+    });
+    const providerConfig = deriveProviderConfig(framework, navState);
+    const entry = {
+        campaignId,
+        flowVersion,
+        framework,
+        navState,
+        providerConfig,
+        cachedAt: new Date().toISOString(),
+        dirty: false,
+        dirtyReasons: [],
+    };
+    campaignContextCache.set(campaignId, entry);
+    logNavigationDebug("context.refresh.complete", {
+        campaignId,
+        flowVersion,
+        computedStep: navState.computedStep,
+        blockedAt: navState.blockedAt,
+        missing: navState.missing,
+        providerConfigResolved: Boolean(providerConfig),
+    }, campaignId);
+    return entry;
+}
+export function markCampaignContextDirty(campaignId, reason) {
+    const existing = campaignContextCache.get(campaignId);
+    if (existing) {
+        existing.dirty = true;
+        if (!existing.dirtyReasons.includes(reason)) {
+            existing.dirtyReasons.push(reason);
+        }
+        logNavigationDebug("context.mark_dirty.updated", {
+            campaignId,
+            reason,
+            dirtyReasons: existing.dirtyReasons,
+        }, campaignId);
+        return;
+    }
+    // No cached entry yet; record that we should refresh on first request.
+    campaignContextCache.set(campaignId, {
+        campaignId,
+        flowVersion: "v1",
+        framework: {
+            flowVersion: "v1",
+            providerRegistry: null,
+            providers: {},
+            overrides: {},
+            warnings: ["frameworkNotLoaded"],
+        },
+        navState: {
+            campaignId,
+            computedStep: "campaign-created",
+            blockedAt: "campaign-created",
+            missing: ["campaignContextNotLoaded"],
+            expectedHeadlessStep: "create-offer",
+            headlessCurrentStep: null,
+            uiStep: "plan",
+            table: {
+                workflowTableId: null,
+                checked: false,
+                rowCount: null,
+                hasRows: null,
+            },
+            context: {
+                leadSourceType: null,
+                leadSourceProvider: null,
+                selectedLeadListId: null,
+                providerCurrentStep: null,
+            },
+            warnings: [],
+        },
+        providerConfig: null,
+        cachedAt: new Date().toISOString(),
+        dirty: true,
+        dirtyReasons: [reason],
+    });
+    logNavigationDebug("context.mark_dirty.seeded", {
+        campaignId,
+        reason,
+    }, campaignId);
+}
+export const contextToolDefinitions = [
+    {
+        name: "get_campaign_context",
+        description: "Return cached create-campaign context (framework snapshot + navigation diagnostics). Refreshes automatically when state is marked dirty.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignId: {
+                    type: "string",
+                    description: "Campaign offer ID",
+                },
+                flowVersion: {
+                    type: "string",
+                    enum: ["v1", "v2"],
+                    description: "Framework flow version (default: v1)",
+                },
+                refresh: {
+                    type: "boolean",
+                    description: "Force a refresh of campaign state and framework snapshot before returning context.",
+                },
+                includeTableCheck: {
+                    type: "boolean",
+                    description: "When true (default), check workflow table row count using a minimal query.",
+                },
+            },
+            required: ["campaignId"],
+            additionalProperties: false,
+        },
+    },
+];
+export async function getCampaignContext(input) {
+    const flowVersion = input.flowVersion || "v1";
+    const includeTableCheck = input.includeTableCheck !== false;
+    const refreshRequested = input.refresh === true;
+    const cached = campaignContextCache.get(input.campaignId);
+    const shouldRefresh = refreshRequested ||
+        !cached ||
+        cached.flowVersion !== flowVersion ||
+        cached.dirty;
+    logNavigationDebug("context.get.start", {
+        campaignId: input.campaignId,
+        flowVersion,
+        includeTableCheck,
+        refreshRequested,
+        hasCachedEntry: Boolean(cached),
+        cachedFlowVersion: cached?.flowVersion ?? null,
+        cachedDirty: cached?.dirty ?? null,
+        cachedDirtyReasons: cached?.dirtyReasons ?? [],
+        shouldRefresh,
+    }, input.campaignId);
+    const entry = shouldRefresh
+        ? await refreshCampaignContext(input.campaignId, flowVersion, {
+            forceFramework: refreshRequested,
+            includeTableCheck,
+        })
+        : cached;
+    logNavigationDebug("context.get.complete", {
+        campaignId: entry.campaignId,
+        refreshed: shouldRefresh,
+        cachedAt: entry.cachedAt,
+        dirty: entry.dirty,
+        dirtyReasons: entry.dirtyReasons,
+        computedStep: entry.navState.computedStep,
+        blockedAt: entry.navState.blockedAt,
+        missing: entry.navState.missing,
+    }, entry.campaignId);
+    return {
+        campaignId: entry.campaignId,
+        flowVersion: entry.flowVersion,
+        cachedAt: entry.cachedAt,
+        refreshed: shouldRefresh,
+        dirty: entry.dirty,
+        dirtyReasons: entry.dirtyReasons,
+        navigation: entry.navState,
+        providerConfig: entry.providerConfig,
+        framework: entry.framework,
+    };
+}

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

@@ -0,0 +1,73 @@
+export declare const MAX_CSV_DOMAIN_UPLOAD_BYTES: number;
+export declare const MAX_CSV_DOMAIN_UPLOAD_ROWS = 7500;
+export declare const MAX_CSV_DOMAIN_UPLOAD_UNIQUE_DOMAINS = 1000;
+export declare const MAX_CSV_DOMAIN_CARRY_COLUMNS = 20;
+declare const CONFIRMATION_TOKEN_VERSION = "csv-domain-preview-v1";
+export type CsvDomainLimits = {
+    maxBytes: number;
+    maxRows: number;
+    maxUniqueDomains: number;
+    maxCarryColumns: number;
+};
+export type CsvDomainPreview = {
+    resolvedFilePath: string;
+    headers: string[];
+    detectedDomainColumn: string | null;
+    candidateDomainColumns: string[];
+    needsDomainColumnSelection: boolean;
+    suggestedCarryoverColumns: string[];
+    selectedColumns: string[];
+    totalRows: number;
+    rowsWithChosenDomainValue: number;
+    uniqueCandidateDomains: number;
+    duplicateDomainCount: number;
+    invalidDomainCount: number;
+    truncatedDomainCount: number;
+    emptySelectedDomainRowCount: number;
+    duplicatePolicy: "last_wins";
+    limits: CsvDomainLimits;
+    warnings: string[];
+    blockingErrors: string[];
+    confirmationToken: string | null;
+};
+export type CsvDomainConfirmationPayload = {
+    version: typeof CONFIRMATION_TOKEN_VERSION;
+    filePath: string;
+    fileSizeBytes: number;
+    fileMtimeMs: number;
+    domainColumn: string;
+    selectedColumns: string[];
+};
+export type CsvDomainPreviewBuild = {
+    preview: CsvDomainPreview;
+    fileSizeBytes: number;
+    fileMtimeMs: number;
+    resolvedDomainColumn: string | null;
+    parsedRows: Array<Record<string, string>>;
+    keptCandidateDomains: string[];
+};
+type ParseCsvDomainFileInput = {
+    filePath: string;
+    workspaceRoot?: string;
+};
+type BuildCsvDomainPreviewInput = ParseCsvDomainFileInput & {
+    domainColumn?: string;
+    selectedColumns?: string[];
+};
+type ParsedCsvDomainFile = {
+    resolvedFilePath: string;
+    fileSizeBytes: number;
+    fileMtimeMs: number;
+    headers: string[];
+    rows: Array<Record<string, string>>;
+    totalRows: number;
+    blockingErrors: string[];
+    warnings: string[];
+};
+export declare function makeConfirmationToken(payload: CsvDomainConfirmationPayload): string;
+export declare function parseConfirmationToken(token: string): CsvDomainConfirmationPayload;
+export declare function matchesConfirmationToken(token: string, payload: CsvDomainConfirmationPayload): boolean;
+export declare function parseCsvDomainFile(input: ParseCsvDomainFileInput): ParsedCsvDomainFile;
+export declare function buildCsvDomainPreview(input: BuildCsvDomainPreviewInput): CsvDomainPreviewBuild;
+export declare function projectCsvCarryRows(previewBuild: CsvDomainPreviewBuild): Array<Record<string, string>>;
+export {};