@sellable/mcp 0.1.0

package/dist/tools/navigation.js

@@ -0,0 +1,381 @@
+import { existsSync, readFileSync } from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
+import { getApi } from "../api.js";
+import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
+import { getTableRowsMinimal } from "./rows.js";
+const entryPath = process.argv[1] ? resolve(process.argv[1]) : process.cwd();
+const entryDir = dirname(entryPath);
+const workspaceRoot = resolveWorkspaceRoot(entryDir);
+const frameworkRoot = join(workspaceRoot, "mcp/sellable/skills/create-campaign");
+function isTruthyFlag(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return (normalized === "1" ||
+        normalized === "true" ||
+        normalized === "yes" ||
+        normalized === "on" ||
+        normalized === "all" ||
+        normalized === "debug");
+}
+function isFalsyFlag(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return (normalized === "0" ||
+        normalized === "false" ||
+        normalized === "no" ||
+        normalized === "off");
+}
+function isNavigationDebugEnabled() {
+    const primary = process.env.SELLABLE_NAV_DEBUG;
+    const secondary = process.env.SELLABLE_DEBUG_NAVIGATION;
+    // Keep test output stable unless explicitly requested.
+    if (process.env.NODE_ENV === "test") {
+        if (isTruthyFlag(primary) || isTruthyFlag(secondary))
+            return true;
+        if (isFalsyFlag(primary) || isFalsyFlag(secondary))
+            return false;
+        return false;
+    }
+    if (isTruthyFlag(primary) || isTruthyFlag(secondary))
+        return true;
+    if (isFalsyFlag(primary) || isFalsyFlag(secondary))
+        return false;
+    // Default-off in production; enable explicitly via env flags.
+    return false;
+}
+function getNavigationDebugCampaignFilters() {
+    const raw = process.env.SELLABLE_NAV_DEBUG_CAMPAIGN_IDS ||
+        process.env.SELLABLE_NAV_DEBUG_CAMPAIGNS ||
+        "";
+    const ids = raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    return ids.length > 0 ? new Set(ids) : null;
+}
+function shouldLogNavigation(campaignId) {
+    if (!isNavigationDebugEnabled())
+        return false;
+    const filters = getNavigationDebugCampaignFilters();
+    if (!filters)
+        return true;
+    if (!campaignId)
+        return false;
+    return filters.has(campaignId);
+}
+export function logNavigationDebug(event, payload = {}, campaignId) {
+    const effectiveCampaignId = campaignId ||
+        (typeof payload.campaignId === "string" ? payload.campaignId : null);
+    if (!shouldLogNavigation(effectiveCampaignId))
+        return;
+    // MCP stdio protocol uses stdout; write diagnostics to stderr only.
+    console.error(`[sellable:navigation] ${JSON.stringify({
+        ts: new Date().toISOString(),
+        event,
+        ...payload,
+    })}`);
+}
+function resolveFromRoot(filePath) {
+    if (isAbsolute(filePath))
+        return filePath;
+    return resolve(workspaceRoot, filePath);
+}
+function readJson(filePath) {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+}
+function loadProviderConfigs() {
+    const registryPath = join(frameworkRoot, "core/providers/registry.json");
+    if (!existsSync(registryPath)) {
+        logNavigationDebug("provider_configs.registry_missing", {
+            registryPath,
+            workspaceRoot,
+        });
+        return {};
+    }
+    const registry = readJson(registryPath);
+    const configs = {};
+    const failures = [];
+    for (const entry of registry.providers) {
+        try {
+            const configPath = resolveFromRoot(entry.configPath);
+            const cfg = readJson(configPath);
+            configs[entry.id] = cfg;
+        }
+        catch (error) {
+            failures.push({
+                providerId: entry.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Ignore provider config failures; diagnostics will reflect missing data.
+        }
+    }
+    logNavigationDebug("provider_configs.loaded", {
+        registryPath,
+        providerCount: Object.keys(configs).length,
+        providerIds: Object.keys(configs),
+        failedCount: failures.length,
+        failures,
+    });
+    return configs;
+}
+function getBriefContent(brief) {
+    if (!brief)
+        return "";
+    if (typeof brief === "string")
+        return brief;
+    return brief.content || "";
+}
+function checkCampaignCreated(campaign) {
+    const missing = [];
+    if (!campaign.id)
+        missing.push("campaignId");
+    if (!campaign.clientProspectId)
+        missing.push("clientProspectId");
+    if (!getBriefContent(campaign.campaignBrief).trim()) {
+        missing.push("campaignBrief.content");
+    }
+    return { stepId: "campaign-created", missing };
+}
+function checkPickProvider(campaign) {
+    const missing = [];
+    if (!campaign.leadSourceType) {
+        missing.push("leadSourceType");
+    }
+    return { stepId: "pick-provider", missing };
+}
+function checkProviderSearch(campaign) {
+    const missing = [];
+    if (campaign.leadSourceType !== "new") {
+        return { stepId: "provider-search", missing };
+    }
+    if (!campaign.leadSourceProvider)
+        missing.push("leadSourceProvider");
+    return { stepId: "provider-search", missing };
+}
+function checkConfirmLeadList(campaign, hasWorkflowRows, enforceRowCheck) {
+    const missing = [];
+    if (!campaign.selectedLeadListId)
+        missing.push("selectedLeadListId");
+    if (!campaign.workflowTableId)
+        missing.push("workflowTableId");
+    if (enforceRowCheck && hasWorkflowRows === false) {
+        missing.push("workflowTableRows");
+    }
+    return { stepId: "confirm-lead-list", missing };
+}
+function mapHeadlessToUiStep(step) {
+    if (!step)
+        return null;
+    if (step === "configure-columns" || step === "confirm-lead-list") {
+        return "leads";
+    }
+    if (step === "create-offer")
+        return "plan";
+    if (step === "pick-provider")
+        return "pick-provider";
+    if (step === "apollo" || step === "sales-nav" || step === "prospeo") {
+        return "contact-search";
+    }
+    if (step === "signal-discovery")
+        return "signal-discovery";
+    if (step === "signal-discovery-results")
+        return "leads";
+    if (step === "filter-choice")
+        return "filter-choice";
+    return null;
+}
+export const navigationToolDefinitions = [
+    {
+        name: "get_campaign_navigation_state",
+        description: "Internal/debug: compute deterministic create-campaign navigation state and diagnostics from the saved campaign plus a lightweight table row-count check.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignId: {
+                    type: "string",
+                    description: "Campaign offer ID",
+                },
+                includeTableCheck: {
+                    type: "boolean",
+                    description: "When true (default), check workflow table row count using a minimal query.",
+                },
+            },
+            required: ["campaignId"],
+            additionalProperties: false,
+        },
+    },
+];
+export function computeCampaignNavigationStateFromCampaign(campaign, options) {
+    const briefContent = getBriefContent(campaign.campaignBrief);
+    logNavigationDebug("compute.start", {
+        campaignId: campaign.id,
+        campaign: {
+            id: campaign.id,
+            clientProspectId: campaign.clientProspectId ?? null,
+            hasOfferPositioning: Boolean(campaign.offerPositioning),
+            briefLength: briefContent.trim().length,
+            leadSourceType: campaign.leadSourceType ?? null,
+            leadSourceProvider: campaign.leadSourceProvider ?? null,
+            selectedLeadListId: campaign.selectedLeadListId ?? null,
+            workflowTableId: campaign.workflowTableId ?? null,
+            currentStep: campaign.currentStep ?? null,
+        },
+        options: {
+            includeTableCheck: options.includeTableCheck,
+            tableChecked: options.tableChecked,
+            rowCount: options.rowCount,
+            hasWorkflowRows: options.hasWorkflowRows,
+            initialWarningsCount: options.initialWarnings?.length ?? 0,
+        },
+    }, campaign.id);
+    const warnings = [...(options.initialWarnings || [])];
+    const providerConfigs = loadProviderConfigs();
+    const providerConfig = campaign.leadSourceProvider
+        ? providerConfigs[campaign.leadSourceProvider]
+        : undefined;
+    const enforceRowCheck = options.includeTableCheck && options.tableChecked;
+    if (options.includeTableCheck &&
+        campaign.workflowTableId &&
+        !options.tableChecked) {
+        warnings.push("Workflow table row count not checked.");
+    }
+    const checks = [
+        checkCampaignCreated(campaign),
+        checkPickProvider(campaign),
+        checkProviderSearch(campaign),
+        checkConfirmLeadList(campaign, options.hasWorkflowRows, enforceRowCheck),
+    ];
+    let computedStep = "campaign-created";
+    let blockedAt = null;
+    let missing = [];
+    for (const check of checks) {
+        logNavigationDebug("compute.check", {
+            campaignId: campaign.id,
+            stepId: check.stepId,
+            missing: check.missing,
+            passed: check.missing.length === 0,
+        }, campaign.id);
+        if (check.missing.length > 0) {
+            blockedAt = check.stepId;
+            missing = check.missing;
+            break;
+        }
+        computedStep = check.stepId;
+    }
+    const expectedHeadlessStep = computedStep === "campaign-created"
+        ? "create-offer"
+        : computedStep === "provider-search"
+            ? providerConfig?.currentStep || campaign.leadSourceProvider || null
+            : computedStep;
+    const stepAligned = !campaign.currentStep || !expectedHeadlessStep
+        ? null
+        : campaign.currentStep === expectedHeadlessStep;
+    if (stepAligned === false && campaign.currentStep && expectedHeadlessStep) {
+        warnings.push(`Headless step mismatch: expected "${expectedHeadlessStep}" but campaign.currentStep is "${campaign.currentStep}".`);
+    }
+    if (!providerConfig && campaign.leadSourceProvider) {
+        warnings.push(`Provider config not found for "${campaign.leadSourceProvider}".`);
+    }
+    const result = {
+        campaignId: campaign.id,
+        computedStep,
+        blockedAt,
+        missing,
+        expectedHeadlessStep,
+        headlessCurrentStep: campaign.currentStep ?? null,
+        uiStep: mapHeadlessToUiStep(campaign.currentStep),
+        table: {
+            workflowTableId: campaign.workflowTableId ?? null,
+            checked: options.tableChecked,
+            rowCount: options.rowCount,
+            hasRows: options.hasWorkflowRows,
+        },
+        context: {
+            leadSourceType: campaign.leadSourceType ?? null,
+            leadSourceProvider: campaign.leadSourceProvider ?? null,
+            selectedLeadListId: campaign.selectedLeadListId ?? null,
+            providerCurrentStep: providerConfig?.currentStep ?? null,
+        },
+        warnings,
+    };
+    logNavigationDebug("compute.result", {
+        campaignId: campaign.id,
+        computedStep: result.computedStep,
+        blockedAt: result.blockedAt,
+        missing: result.missing,
+        expectedHeadlessStep: result.expectedHeadlessStep,
+        headlessCurrentStep: result.headlessCurrentStep,
+        uiStep: result.uiStep,
+        table: result.table,
+        context: result.context,
+        warnings: result.warnings,
+    }, campaign.id);
+    return result;
+}
+export async function getCampaignNavigationState(input) {
+    const includeTableCheck = input.includeTableCheck !== false;
+    const api = getApi();
+    logNavigationDebug("state.fetch_campaign.start", {
+        campaignId: input.campaignId,
+        includeTableCheck,
+    }, input.campaignId);
+    const campaign = await api.get(`/api/v2/campaign-offers/${input.campaignId}`);
+    logNavigationDebug("state.fetch_campaign.success", {
+        campaignId: input.campaignId,
+        workflowTableId: campaign.workflowTableId ?? null,
+        currentStep: campaign.currentStep ?? null,
+        leadSourceProvider: campaign.leadSourceProvider ?? null,
+        selectedLeadListId: campaign.selectedLeadListId ?? null,
+    }, input.campaignId);
+    let tableRowCount = null;
+    let hasWorkflowRows = null;
+    const warnings = [];
+    let tableChecked = false;
+    if (includeTableCheck && campaign.workflowTableId) {
+        logNavigationDebug("state.table_check.start", {
+            campaignId: input.campaignId,
+            workflowTableId: campaign.workflowTableId,
+        }, input.campaignId);
+        try {
+            const rows = await getTableRowsMinimal(campaign.workflowTableId, {
+                limit: 1,
+                page: 1,
+            });
+            tableChecked = true;
+            tableRowCount = rows.pagination?.totalCount ?? 0;
+            hasWorkflowRows = tableRowCount > 0;
+            logNavigationDebug("state.table_check.success", {
+                campaignId: input.campaignId,
+                workflowTableId: campaign.workflowTableId,
+                rowCount: tableRowCount,
+                hasRows: hasWorkflowRows,
+            }, input.campaignId);
+        }
+        catch (error) {
+            warnings.push(`Failed to check workflow table rows: ${error instanceof Error ? error.message : String(error)}`);
+            logNavigationDebug("state.table_check.error", {
+                campaignId: input.campaignId,
+                workflowTableId: campaign.workflowTableId,
+                error: error instanceof Error ? error.message : String(error),
+            }, input.campaignId);
+        }
+    }
+    const result = computeCampaignNavigationStateFromCampaign(campaign, {
+        includeTableCheck,
+        tableChecked,
+        rowCount: tableRowCount,
+        hasWorkflowRows,
+        initialWarnings: warnings,
+    });
+    logNavigationDebug("state.complete", {
+        campaignId: input.campaignId,
+        computedStep: result.computedStep,
+        blockedAt: result.blockedAt,
+        missing: result.missing,
+        warnings: result.warnings,
+    }, input.campaignId);
+    return result;
+}

package/dist/tools/one-off.d.ts

@@ -0,0 +1,229 @@
+export type CreateOnDemandTableInput = {
+    name: string;
+    senderIds?: string[];
+    clientProspectId: string;
+    offerPositioning?: Record<string, unknown>;
+    campaignBrief?: unknown;
+};
+export type AddOnDemandLeadsInput = {
+    tableId: string;
+    leads: Array<{
+        linkedinUrl: string;
+        name?: string;
+        title?: string;
+        companyWebsite?: string;
+        location?: string;
+    }>;
+    skipDuplicates?: boolean;
+};
+export type OnDemandTableIdInput = {
+    tableId: string;
+};
+export type InitOnDemandSequenceInput = {
+    tableId: string;
+    template?: Record<string, unknown>;
+    confirmed?: boolean;
+};
+export type CreateOnDemandCampaignInput = {
+    name: string;
+    clientProspectId: string;
+    senderIds: string[];
+    campaignBrief?: unknown;
+    offerPositioning?: Record<string, unknown>;
+    sequenceTemplate?: Record<string, unknown>;
+    confirmed?: boolean;
+};
+export declare const onDemandToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            senderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            clientProspectId: {
+                type: string;
+                description: string;
+            };
+            offerPositioning: {
+                type: string;
+                description: string;
+            };
+            campaignBrief: {
+                description: string;
+            };
+            sequenceTemplate?: undefined;
+            confirmed?: undefined;
+            tableId?: undefined;
+            leads?: undefined;
+            skipDuplicates?: undefined;
+            template?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            clientProspectId: {
+                type: string;
+                description: string;
+            };
+            senderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            campaignBrief: {
+                description: string;
+            };
+            offerPositioning: {
+                type: string;
+                description: string;
+            };
+            sequenceTemplate: {
+                type: string;
+                description: string;
+            };
+            confirmed: {
+                type: string;
+                description: string;
+            };
+            tableId?: undefined;
+            leads?: undefined;
+            skipDuplicates?: undefined;
+            template?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+                description: string;
+            };
+            leads: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        linkedinUrl: {
+                            type: string;
+                        };
+                        name: {
+                            type: string;
+                        };
+                        title: {
+                            type: string;
+                        };
+                        companyWebsite: {
+                            type: string;
+                        };
+                        location: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            skipDuplicates: {
+                type: string;
+                description: string;
+            };
+            name?: undefined;
+            senderIds?: undefined;
+            clientProspectId?: undefined;
+            offerPositioning?: undefined;
+            campaignBrief?: undefined;
+            sequenceTemplate?: undefined;
+            confirmed?: undefined;
+            template?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+                description?: undefined;
+            };
+            name?: undefined;
+            senderIds?: undefined;
+            clientProspectId?: undefined;
+            offerPositioning?: undefined;
+            campaignBrief?: undefined;
+            sequenceTemplate?: undefined;
+            confirmed?: undefined;
+            leads?: undefined;
+            skipDuplicates?: undefined;
+            template?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+                description?: undefined;
+            };
+            template: {
+                type: string;
+                description: string;
+            };
+            confirmed: {
+                type: string;
+                description: string;
+            };
+            name?: undefined;
+            senderIds?: undefined;
+            clientProspectId?: undefined;
+            offerPositioning?: undefined;
+            campaignBrief?: undefined;
+            sequenceTemplate?: undefined;
+            leads?: undefined;
+            skipDuplicates?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function createOnDemandTable(input: CreateOnDemandTableInput): Promise<unknown>;
+export declare function addOnDemandLeads(input: AddOnDemandLeadsInput): Promise<unknown>;
+export declare function startOnDemandCampaign(input: OnDemandTableIdInput): Promise<unknown>;
+export declare function pauseOnDemandCampaign(input: OnDemandTableIdInput): Promise<unknown>;
+export declare function initOnDemandSequence(input: InitOnDemandSequenceInput): Promise<unknown>;
+export declare function createOnDemandCampaign(input: CreateOnDemandCampaignInput): Promise<{
+    tableId: string;
+    campaignOfferId: string;
+    senderIds: string[];
+    sequenceInitialized: boolean;
+}>;