@sellable/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Sellable MCP Server - Production
+ *
+ * Uses ~/.claude/sellable.json config (default prod URL: https://app.sellable.dev)
+ */
+// Uses default config (sellable.json), just import and run
+import "./server.js";

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,499 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getSkillByName, listSkills, stripFrontmatter } from "./skills.js";
+import { authToolDefinitions, getAuthStatus } from "./tools/auth.js";
+import { blueprintCommitToolDefinitions, handleAddColumn, handleCommitBlueprint, } from "./tools/blueprint-commit.js";
+import { bootstrapCreateCampaign, bootstrapToolDefinitions, } from "./tools/bootstrap.js";
+import { campaignToolDefinitions, createCampaign, enrichSender, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
+import { cellToolDefinitions, queueCells, updateCell } from "./tools/cells.js";
+import { contextToolDefinitions, getCampaignContext, hydrateCampaignContextFromCampaign, markCampaignContextDirty, } from "./tools/context.js";
+import { addToCommentCampaign, addToConnectionCampaign, addToInmailCampaign, directCampaignToolDefinitions, getEngagedPosts, getOrCreateDirectCampaignTable, pauseDirectCampaign, startDirectCampaign, } from "./tools/direct-campaigns.js";
+import { bootstrapEngage, bootstrapEngageMulti, engageBootstrapToolDefinitions, } from "./tools/engage-bootstrap.js";
+import { engageDiscoveryToolDefinitions, searchEngagementPosts, } from "./tools/engage-discovery.js";
+import { copySenderConfigTool, engageMemoryToolDefinitions, getEngageMemoryTool, migrateFlatConfigsTool, recordEngageProvenSearchTool, setEngageStyleGuideTool, upsertEngageTrackedPersonTool, } from "./tools/engage-memory.js";
+import { engageStateToolDefinitions, getEngageStateTool, setEngageStateTool, } from "./tools/engage-state.js";
+import { bulkEnrichWithProspeo, enrichmentToolDefinitions, enrichWithProspeo, getProspeoCredits, } from "./tools/enrichment.js";
+import { frameworkToolDefinitions, getCampaignFramework, } from "./tools/framework.js";
+import { cancelLeadImport, confirmLeadList, getProviderPrompt, importLeads, leadToolDefinitions, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
+import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfile, fetchPostEngagers, getLinkedInProfile, getUserPosts, linkedinToolDefinitions, } from "./tools/linkedin.js";
+import { getCampaignNavigationState, navigationToolDefinitions, } from "./tools/navigation.js";
+import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDemandSequence, onDemandToolDefinitions, pauseOnDemandCampaign, startOnDemandCampaign, } from "./tools/one-off.js";
+import { processingToolDefinitions, upsertRubric } from "./tools/processing.js";
+import { completeSenderResearch, getMessagePrompt, getSubskillPrompt, listSubskillPrompts, promptToolDefinitions, searchSubskillPrompts, } from "./tools/prompts.js";
+import { readinessToolDefinitions, waitForCampaignTableReady, waitForLeadListReady, } from "./tools/readiness.js";
+import { getRows, getTableRows, getTableRowsMinimal, rowToolDefinitions, } from "./tools/rows.js";
+import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, rubricToolDefinitions, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
+import { getSender, listSenders, senderToolDefinitions, } from "./tools/senders.js";
+import { attachRecommendedSequence, attachSequence, createWorkflowTable, sequencerToolDefinitions, } from "./tools/sequencer.js";
+import { listTables, tableToolDefinitions } from "./tools/tables.js";
+import { handleVerifyTableRow, verifyRowToolDefinitions, } from "./tools/verify-row.js";
+import { addTeammate, createWorkspace, getActiveWorkspace, listWorkspaces, setActiveWorkspace, workspaceToolDefinitions, } from "./tools/workspaces.js";
+const server = new Server({
+    name: "sellable-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+        prompts: {},
+    },
+});
+const allTools = [
+    ...campaignToolDefinitions,
+    ...authToolDefinitions,
+    ...bootstrapToolDefinitions,
+    ...engageBootstrapToolDefinitions,
+    ...engageDiscoveryToolDefinitions,
+    ...workspaceToolDefinitions,
+    ...frameworkToolDefinitions,
+    ...contextToolDefinitions,
+    ...navigationToolDefinitions,
+    ...leadToolDefinitions,
+    ...enrichmentToolDefinitions,
+    ...processingToolDefinitions,
+    ...rubricToolDefinitions,
+    ...readinessToolDefinitions,
+    ...rowToolDefinitions,
+    ...cellToolDefinitions,
+    ...promptToolDefinitions,
+    ...linkedinToolDefinitions,
+    ...onDemandToolDefinitions,
+    ...directCampaignToolDefinitions,
+    ...senderToolDefinitions,
+    ...engageStateToolDefinitions,
+    ...engageMemoryToolDefinitions,
+    ...sequencerToolDefinitions,
+    ...tableToolDefinitions,
+    ...blueprintCommitToolDefinitions,
+    ...verifyRowToolDefinitions,
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: allTools,
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case "get_auth_status":
+                result = await getAuthStatus();
+                break;
+            case "bootstrap_engage":
+                result = await bootstrapEngage(args);
+                break;
+            case "bootstrap_engage_multi":
+                result = await bootstrapEngageMulti(args);
+                break;
+            case "search_engagement_posts":
+                result = await searchEngagementPosts(args);
+                break;
+            case "get_engage_state":
+                result = getEngageStateTool();
+                break;
+            case "set_engage_state":
+                result = setEngageStateTool(args);
+                break;
+            case "get_engage_memory":
+                result = getEngageMemoryTool(args);
+                break;
+            case "set_engage_style_guide":
+                result = setEngageStyleGuideTool(args);
+                break;
+            case "record_engage_proven_search":
+                result = recordEngageProvenSearchTool(args);
+                break;
+            case "upsert_engage_tracked_person":
+                result = upsertEngageTrackedPersonTool(args);
+                break;
+            case "copy_sender_config":
+                result = copySenderConfigTool(args);
+                break;
+            case "migrate_flat_configs":
+                result = migrateFlatConfigsTool(args);
+                break;
+            case "list_workspaces":
+                result = await listWorkspaces();
+                break;
+            case "get_active_workspace":
+                result = getActiveWorkspace();
+                break;
+            case "set_active_workspace":
+                result = await setActiveWorkspace(args?.workspaceId, args?.userConfirmed);
+                break;
+            case "create_workspace":
+                result = await createWorkspace(args?.name);
+                break;
+            case "create_workflow_table":
+                result = await createWorkflowTable(args);
+                break;
+            case "attach_sequence":
+                result = await attachSequence(args);
+                break;
+            case "attach_recommended_sequence":
+                result = await attachRecommendedSequence(args);
+                break;
+            case "bootstrap_create_campaign":
+                result = await bootstrapCreateCampaign(args);
+                break;
+            case "add_teammate":
+                result = await addTeammate(args);
+                break;
+            case "enrich_sender":
+                result = await enrichSender(args?.linkedinUrl, args?.companyDomain, args?.forceRefresh);
+                break;
+            case "get_campaigns":
+                result = await getCampaigns(args?.limit);
+                break;
+            case "get_campaign":
+                result = await getCampaign(args?.campaignId);
+                break;
+            case "get_campaign_messages_preview":
+                result = await getCampaignMessagesPreview(args);
+                break;
+            case "create_campaign":
+                result = await createCampaign(args);
+                if (result?.id)
+                    markCampaignContextDirty(result.id, "create_campaign");
+                break;
+            case "update_campaign":
+                result = await updateCampaign(args?.campaignId, args);
+                if (result?._campaign?.id) {
+                    const entry = hydrateCampaignContextFromCampaign(result._campaign, "update_campaign");
+                    result.navigation = entry.navState;
+                    delete result._campaign;
+                }
+                else if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "update_campaign");
+                }
+                break;
+            case "start_campaign":
+                result = await startCampaign(args?.campaignId);
+                break;
+            case "pause_campaign":
+                result = await pauseCampaign(args?.campaignId);
+                break;
+            case "update_campaign_brief":
+                result = await updateCampaignBrief(args?.campaignId, args?.campaignBrief);
+                if (args?.campaignId) {
+                    markCampaignContextDirty(args.campaignId, "update_campaign_brief");
+                }
+                break;
+            case "get_campaign_framework":
+                result = getCampaignFramework(args);
+                break;
+            case "get_campaign_context":
+                result = await getCampaignContext(args);
+                break;
+            case "get_campaign_navigation_state":
+                result = await getCampaignNavigationState(args);
+                break;
+            case "get_table_rows":
+                result = await getTableRows(args?.tableId, {
+                    limit: args?.limit,
+                    page: args?.page,
+                });
+                break;
+            case "get_rows_minimal":
+                result = await getTableRowsMinimal(args?.tableId, {
+                    limit: args?.limit,
+                    page: args?.page,
+                });
+                break;
+            case "list_tables":
+                result = await listTables(args);
+                break;
+            case "commit_blueprint":
+                result = await handleCommitBlueprint(args);
+                break;
+            case "add_column":
+                result = await handleAddColumn(args);
+                break;
+            case "verify_table_row":
+                result = await handleVerifyTableRow(args);
+                break;
+            case "get_rows":
+                result = await getRows(args?.tableId, args?.rowIds);
+                break;
+            case "create_on_demand_table":
+            case "create_one_off_table":
+                result = await createOnDemandTable(args);
+                break;
+            case "create_on_demand_campaign":
+                result = await createOnDemandCampaign(args);
+                break;
+            case "add_on_demand_leads":
+            case "add_one_off_leads":
+                result = await addOnDemandLeads(args);
+                break;
+            case "start_on_demand_campaign":
+            case "start_one_off_campaign":
+                result = await startOnDemandCampaign(args);
+                break;
+            case "pause_on_demand_campaign":
+            case "pause_one_off_campaign":
+                result = await pauseOnDemandCampaign(args);
+                break;
+            case "init_on_demand_sequence":
+            case "init_one_off_sequence":
+                result = await initOnDemandSequence(args);
+                break;
+            case "add_to_inmail_campaign":
+                result = await addToInmailCampaign(args);
+                break;
+            case "add_to_connection_campaign":
+                result = await addToConnectionCampaign(args);
+                break;
+            case "add_to_comment_campaign":
+                result = await addToCommentCampaign(args);
+                break;
+            case "start_direct_campaign":
+                result = await startDirectCampaign(args);
+                break;
+            case "pause_direct_campaign":
+                result = await pauseDirectCampaign(args);
+                break;
+            case "get_or_create_direct_campaign_table":
+                result = await getOrCreateDirectCampaignTable(args);
+                break;
+            case "get_engaged_posts":
+                result = await getEngagedPosts(args);
+                break;
+            case "list_senders":
+                result = await listSenders();
+                break;
+            case "get_sender":
+                result = await getSender(args);
+                break;
+            case "search_apollo":
+                result = await searchApollo(args);
+                break;
+            case "lookup_sales_nav_filter":
+                result = await lookupSalesNavFilter(args);
+                break;
+            case "search_sales_nav":
+                result = await searchSalesNav(args);
+                break;
+            case "search_prospeo":
+                result = await searchProspeo(args);
+                break;
+            case "load_csv_domains":
+                result = await loadCsvDomains(args);
+                break;
+            case "load_csv_linkedin_leads":
+                result = await loadCsvLinkedinLeads(args);
+                break;
+            case "save_domain_filters":
+                result = await saveDomainFilters(args);
+                break;
+            case "search_signals":
+                result = await searchSignals(args);
+                break;
+            case "import_leads":
+                result = await importLeads(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "import_leads");
+                }
+                break;
+            case "cancel_lead_import":
+                result = await cancelLeadImport(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "cancel_lead_import");
+                }
+                break;
+            case "confirm_lead_list":
+                result = await confirmLeadList(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "confirm_lead_list");
+                }
+                break;
+            case "wait_for_campaign_table_ready":
+                result = await waitForCampaignTableReady(args);
+                break;
+            case "wait_for_lead_list_ready":
+                result = await waitForLeadListReady(args);
+                break;
+            case "upsert_rubric":
+                result = await upsertRubric(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "upsert_rubric");
+                }
+                break;
+            case "draft_rubrics":
+                result = await draftRubrics(args);
+                break;
+            case "select_necessary_rubrics":
+                result = await selectNecessaryRubrics(args);
+                break;
+            case "save_rubrics":
+                result = await saveRubrics(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "save_rubrics");
+                }
+                break;
+            case "add_rubric_item":
+                result = await addRubricItem(args);
+                break;
+            case "update_rubric_item":
+                result = await updateRubricItem(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "update_rubric_item");
+                }
+                break;
+            case "delete_rubric_item":
+                result = await deleteRubricItem(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "delete_rubric_item");
+                }
+                break;
+            case "check_rubric":
+                result = await checkRubric(args);
+                break;
+            case "wait_for_rubric_results":
+                result = await waitForRubricResults(args);
+                break;
+            case "update_cell":
+                result = await updateCell(args?.cellId, args?.value);
+                break;
+            case "queue_cells":
+                result = await queueCells(args?.tableId, args?.cellIds);
+                break;
+            case "get_message_prompt":
+                result = await getMessagePrompt();
+                break;
+            case "get_subskill_prompt":
+                result = getSubskillPrompt(args?.subskillName, args?.offset, args?.limit);
+                break;
+            case "list_subskill_prompts":
+                result = listSubskillPrompts(args?.limit, args?.includePublic, args?.includeInternal);
+                break;
+            case "search_subskill_prompts":
+                result = searchSubskillPrompts(args?.query, args?.limit, args?.includePublic, args?.includeInternal);
+                break;
+            case "complete_sender_research":
+                result = completeSenderResearch(args);
+                break;
+            case "fetch_linkedin_posts":
+                result = await fetchLinkedInPosts(args?.linkedinUrl, args?.limit);
+                break;
+            case "fetch_linkedin_profile":
+                result = await fetchLinkedInProfile(args?.linkedinUrl);
+                break;
+            case "fetch_company":
+                result = await fetchCompany(args?.companyUrl);
+                break;
+            case "fetch_company_posts":
+                result = await fetchCompanyPosts(args?.companyUrl, args?.limit, args?.sortBy || "recent");
+                break;
+            case "get_user_posts":
+                result = await getUserPosts(args?.linkedin_url, args?.max_posts);
+                break;
+            case "get_linkedin_profile":
+                result = await getLinkedInProfile(args?.linkedin_url);
+                break;
+            case "fetch_post_engagers":
+                result = await fetchPostEngagers(args?.postUrl, args?.sources || "both", args?.limit);
+                break;
+            case "get_provider_prompt":
+                result = getProviderPrompt(args);
+                break;
+            case "select_promising_posts":
+                result = await selectPromisingPosts(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "select_promising_posts");
+                }
+                break;
+            case "set_headline_icp_criteria":
+                result = await setHeadlineICPCriteria(args);
+                if (args?.campaignOfferId) {
+                    markCampaignContextDirty(args.campaignOfferId, "set_headline_icp_criteria");
+                }
+                break;
+            case "enrich_with_prospeo":
+                result = await enrichWithProspeo(args);
+                break;
+            case "bulk_enrich_with_prospeo":
+                result = await bulkEnrichWithProspeo(args);
+                break;
+            case "get_prospeo_credits":
+                result = await getProspeoCredits();
+                break;
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// List available prompts (skills)
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: listSkills("public").map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+    })),
+}));
+// Get prompt content
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name } = request.params;
+    const skill = getSkillByName(name);
+    if (!skill) {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+    const content = stripFrontmatter(skill.content);
+    return {
+        description: skill.description,
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: content,
+                },
+            },
+        ],
+    };
+});
+async function main() {
+    const startTime = Date.now();
+    console.error(`[sellable-mcp] pid=${process.pid} starting...`);
+    const transport = new StdioServerTransport();
+    // Exit cleanly when parent disconnects stdin (Claude Code closed/reconnected)
+    process.stdin.on("end", () => {
+        console.error(`[sellable-mcp] pid=${process.pid} stdin closed, exiting`);
+        process.exit(0);
+    });
+    process.stdin.on("error", () => {
+        process.exit(0);
+    });
+    // Handle termination signals
+    const shutdown = (signal) => {
+        console.error(`[sellable-mcp] pid=${process.pid} received ${signal}, exiting`);
+        process.exit(0);
+    };
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    await server.connect(transport);
+    const elapsed = Date.now() - startTime;
+    console.error(`[sellable-mcp] pid=${process.pid} ready in ${elapsed}ms (tools=${allTools.length})`);
+}
+main().catch((error) => {
+    console.error(`[sellable-mcp] pid=${process.pid} failed to start:`, error);
+    process.exit(1);
+});

package/dist/skills.d.ts

@@ -0,0 +1,11 @@
+export type SkillVisibility = "public" | "internal";
+export interface SkillDefinition {
+    name: string;
+    description: string;
+    content: string;
+    visibility: SkillVisibility;
+}
+export declare function loadSkills(force?: boolean): SkillDefinition[];
+export declare function listSkills(visibility?: SkillVisibility): SkillDefinition[];
+export declare function getSkillByName(name: string): SkillDefinition | undefined;
+export declare function stripFrontmatter(content: string): string;

package/dist/skills.js

@@ -0,0 +1,97 @@
+import * as fs from "fs";
+import * as path from "path";
+function resolveSkillsDir() {
+    const candidates = [];
+    if (process.env.SELLABLE_SKILLS_DIR) {
+        candidates.push(path.resolve(process.env.SELLABLE_SKILLS_DIR));
+    }
+    if (process.argv[1]) {
+        // When running as CLI, argv[1] is typically ".../dist/index.js".
+        candidates.push(path.resolve(path.dirname(process.argv[1]), "../skills"));
+    }
+    // Local repo execution and test contexts.
+    candidates.push(path.resolve(process.cwd(), "mcp/sellable/skills"));
+    candidates.push(path.resolve(process.cwd(), "skills"));
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Keep a deterministic fallback for callers that want a path even if missing.
+    return candidates[0] ?? path.resolve(process.cwd(), "mcp/sellable/skills");
+}
+let _skillsDir = null;
+function getSkillsDir() {
+    if (!_skillsDir)
+        _skillsDir = resolveSkillsDir();
+    return _skillsDir;
+}
+let cachedSkills = null;
+function parseFrontmatter(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        return {
+            name: "",
+            description: "",
+            visibility: "public",
+        };
+    }
+    const frontmatter = frontmatterMatch[1];
+    const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+    const descriptionMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    const visibilityMatch = frontmatter.match(/^visibility:\s*(.+)$/m);
+    let visibility = "public";
+    if (visibilityMatch) {
+        const parsedVisibility = visibilityMatch[1].trim().toLowerCase();
+        if (parsedVisibility === "internal") {
+            visibility = "internal";
+        }
+    }
+    return {
+        name: nameMatch ? nameMatch[1].trim() : "",
+        description: descriptionMatch ? descriptionMatch[1].trim() : "",
+        visibility,
+    };
+}
+export function loadSkills(force = false) {
+    if (!force && cachedSkills) {
+        return cachedSkills;
+    }
+    const skills = [];
+    const dir_ = getSkillsDir();
+    if (!fs.existsSync(dir_)) {
+        cachedSkills = skills;
+        return skills;
+    }
+    const dirs = fs.readdirSync(dir_, { withFileTypes: true });
+    for (const dir of dirs) {
+        if (!dir.isDirectory())
+            continue;
+        const skillPath = path.join(dir_, dir.name, "SKILL.md");
+        if (!fs.existsSync(skillPath))
+            continue;
+        const content = fs.readFileSync(skillPath, "utf-8");
+        const frontmatter = parseFrontmatter(content);
+        skills.push({
+            name: frontmatter.name || dir.name,
+            description: frontmatter.description || "",
+            content,
+            visibility: frontmatter.visibility,
+        });
+    }
+    cachedSkills = skills;
+    return skills;
+}
+export function listSkills(visibility) {
+    const skills = loadSkills();
+    if (!visibility)
+        return skills;
+    return skills.filter((skill) => skill.visibility === visibility);
+}
+export function getSkillByName(name) {
+    const skills = loadSkills();
+    return skills.find((skill) => skill.name === name);
+}
+export function stripFrontmatter(content) {
+    return content.replace(/^---\n[\s\S]*?\n---\n*/, "");
+}

package/dist/tools/auth.d.ts

@@ -0,0 +1,30 @@
+export type AuthStatus = {
+    ok: boolean;
+    configPath: string;
+    activeEnvName: string | null;
+    apiUrl: string | null;
+    activeWorkspaceId: string | null;
+    activeWorkspaceName: string | null;
+    tokenPrefix: string | null;
+    workspacesCount: number | null;
+    checkedAt: string;
+    /** Short message the LLM MUST show the user after auth succeeds. */
+    _userNotice: string | null;
+    error: null | {
+        type: "config" | "auth" | "workspace" | "api";
+        status?: number;
+        message: string;
+        guidance: string;
+    };
+};
+export declare const authToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function getAuthStatus(): Promise<AuthStatus>;