@magnetlab/mcp 0.1.0

package/dist/handlers/content-pipeline.js

@@ -0,0 +1,127 @@
+/**
+ * Handle content pipeline tool calls.
+ */
+export async function handleContentPipelineTools(name, args, client) {
+    switch (name) {
+        // Transcripts
+        case 'magnetlab_list_transcripts':
+            return client.listTranscripts();
+        case 'magnetlab_submit_transcript':
+            return client.submitTranscript({
+                transcript: args.transcript,
+                title: args.title,
+            });
+        case 'magnetlab_delete_transcript':
+            return client.deleteTranscript(args.id);
+        // Knowledge base
+        case 'magnetlab_search_knowledge':
+            return client.searchKnowledge({
+                query: args.query,
+                category: args.category,
+            });
+        case 'magnetlab_browse_knowledge':
+            return client.searchKnowledge({
+                category: args.category,
+            });
+        case 'magnetlab_get_knowledge_tags':
+            return client.searchKnowledge({ view: 'tags' });
+        case 'magnetlab_get_knowledge_clusters':
+            return client.getKnowledgeClusters();
+        // Ideas
+        case 'magnetlab_list_ideas':
+            return client.listIdeas({
+                status: args.status,
+                pillar: args.pillar,
+                contentType: args.content_type,
+                limit: args.limit,
+            });
+        case 'magnetlab_get_idea':
+            return client.getIdea(args.id);
+        case 'magnetlab_update_idea_status':
+            return client.updateIdeaStatus(args.idea_id, args.status);
+        case 'magnetlab_delete_idea':
+            return client.deleteIdea(args.id);
+        case 'magnetlab_write_post_from_idea':
+            return client.writePostFromIdea(args.idea_id);
+        // Posts
+        case 'magnetlab_list_posts':
+            return client.listPosts({
+                status: args.status,
+                isBuffer: args.is_buffer,
+                limit: args.limit,
+            });
+        case 'magnetlab_get_post':
+            return client.getPost(args.id);
+        case 'magnetlab_update_post': {
+            const { id, ...rest } = args;
+            return client.updatePost(id, rest);
+        }
+        case 'magnetlab_delete_post':
+            return client.deletePost(args.id);
+        case 'magnetlab_polish_post':
+            return client.polishPost(args.id);
+        case 'magnetlab_publish_post':
+            return client.publishPost(args.id);
+        case 'magnetlab_schedule_post':
+            return client.schedulePost({
+                postId: args.post_id,
+                scheduledTime: args.scheduled_time,
+            });
+        case 'magnetlab_get_posts_by_date_range':
+            return client.getPostsByDateRange({
+                startDate: args.start_date,
+                endDate: args.end_date,
+            });
+        case 'magnetlab_quick_write':
+            return client.quickWritePost({
+                topic: args.topic,
+                style: args.style,
+                template: args.template,
+            });
+        // Schedule & Autopilot
+        case 'magnetlab_list_posting_slots':
+            return client.listPostingSlots();
+        case 'magnetlab_create_posting_slot':
+            return client.createPostingSlot({
+                dayOfWeek: args.day_of_week,
+                time: args.time,
+            });
+        case 'magnetlab_delete_posting_slot':
+            return client.deletePostingSlot(args.id);
+        case 'magnetlab_get_autopilot_status':
+            return client.getAutopilotStatus();
+        case 'magnetlab_trigger_autopilot':
+            return client.triggerAutopilot({
+                postsPerBatch: args.posts_per_batch,
+                bufferTarget: args.buffer_target,
+                autoPublish: args.auto_publish,
+            });
+        case 'magnetlab_get_buffer':
+            return client.getBuffer();
+        // Writing Styles & Templates
+        case 'magnetlab_list_writing_styles':
+            return client.listWritingStyles();
+        case 'magnetlab_extract_writing_style':
+            return client.extractWritingStyle({ linkedinUrl: args.linkedin_url });
+        case 'magnetlab_get_writing_style':
+            return client.getWritingStyle(args.id);
+        case 'magnetlab_list_templates':
+            return client.listTemplates({ limit: args.limit });
+        case 'magnetlab_match_template':
+            return client.matchTemplate({ ideaId: args.idea_id });
+        // Content Planner
+        case 'magnetlab_get_plan':
+            return client.getPlan();
+        case 'magnetlab_generate_plan':
+            return client.generatePlan({ weekCount: args.week_count });
+        case 'magnetlab_approve_plan':
+            return client.approvePlan({ planId: args.plan_id });
+        // Business Context
+        case 'magnetlab_get_business_context':
+            return client.getBusinessContext();
+        case 'magnetlab_update_business_context':
+            return client.updateBusinessContext(args.context);
+        default:
+            throw new Error(`Unknown content pipeline tool: ${name}`);
+    }
+}

package/dist/handlers/email-sequences.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle email sequence tool calls.
+ */
+export declare function handleEmailSequenceTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/email-sequences.js

@@ -0,0 +1,30 @@
+/**
+ * Handle email sequence tool calls.
+ */
+export async function handleEmailSequenceTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_get_email_sequence':
+            return client.getEmailSequence(args.lead_magnet_id);
+        case 'magnetlab_generate_email_sequence':
+            return client.generateEmailSequence({
+                leadMagnetId: args.lead_magnet_id,
+                useAI: args.use_ai,
+            });
+        case 'magnetlab_update_email_sequence': {
+            const emails = args.emails;
+            return client.updateEmailSequence(args.lead_magnet_id, {
+                emails: emails?.map((e) => ({
+                    day: e.day,
+                    subject: e.subject,
+                    body: e.body,
+                    replyTrigger: e.reply_trigger,
+                })),
+                status: args.status,
+            });
+        }
+        case 'magnetlab_activate_email_sequence':
+            return client.activateEmailSequence(args.lead_magnet_id);
+        default:
+            throw new Error(`Unknown email sequence tool: ${name}`);
+    }
+}

package/dist/handlers/funnels.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle funnel related tool calls.
+ */
+export declare function handleFunnelTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/funnels.js

@@ -0,0 +1,65 @@
+/**
+ * Handle funnel related tool calls.
+ */
+export async function handleFunnelTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_list_funnels':
+            return client.listFunnels();
+        case 'magnetlab_get_funnel':
+            return client.getFunnel(args.id);
+        case 'magnetlab_get_funnel_by_target':
+            return client.getFunnelByTarget({
+                leadMagnetId: args.lead_magnet_id,
+                libraryId: args.library_id,
+                externalResourceId: args.external_resource_id,
+            });
+        case 'magnetlab_create_funnel':
+            return client.createFunnel({
+                leadMagnetId: args.lead_magnet_id,
+                libraryId: args.library_id,
+                externalResourceId: args.external_resource_id,
+                targetType: args.target_type,
+                slug: args.slug,
+                optinHeadline: args.optin_headline,
+                optinSubline: args.optin_subline,
+                optinButtonText: args.optin_button_text,
+                optinSocialProof: args.optin_social_proof,
+                thankyouHeadline: args.thankyou_headline,
+                thankyouSubline: args.thankyou_subline,
+                vslUrl: args.vsl_url,
+                calendlyUrl: args.calendly_url,
+                theme: args.theme,
+                primaryColor: args.primary_color,
+                backgroundStyle: args.background_style,
+                logoUrl: args.logo_url,
+                qualificationFormId: args.qualification_form_id,
+            });
+        case 'magnetlab_update_funnel':
+            return client.updateFunnel(args.id, {
+                slug: args.slug,
+                optinHeadline: args.optin_headline,
+                optinSubline: args.optin_subline,
+                optinButtonText: args.optin_button_text,
+                optinSocialProof: args.optin_social_proof,
+                thankyouHeadline: args.thankyou_headline,
+                thankyouSubline: args.thankyou_subline,
+                vslUrl: args.vsl_url,
+                calendlyUrl: args.calendly_url,
+                theme: args.theme,
+                primaryColor: args.primary_color,
+                backgroundStyle: args.background_style,
+                logoUrl: args.logo_url,
+                qualificationFormId: args.qualification_form_id,
+            });
+        case 'magnetlab_delete_funnel':
+            return client.deleteFunnel(args.id);
+        case 'magnetlab_publish_funnel':
+            return client.publishFunnel(args.id);
+        case 'magnetlab_unpublish_funnel':
+            return client.unpublishFunnel(args.id);
+        case 'magnetlab_generate_funnel_content':
+            return client.generateFunnelContent({ leadMagnetId: args.lead_magnet_id });
+        default:
+            throw new Error(`Unknown funnel tool: ${name}`);
+    }
+}

package/dist/handlers/ideation.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle ideation and content generation tool calls.
+ */
+export declare function handleIdeationTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/ideation.js

@@ -0,0 +1,44 @@
+/**
+ * Handle ideation and content generation tool calls.
+ */
+export async function handleIdeationTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_ideate_lead_magnets':
+            return client.ideateLeadMagnets({
+                businessDescription: args.business_description,
+                businessType: args.business_type,
+                credibilityMarkers: args.credibility_markers,
+                urgentPains: args.urgent_pains,
+                templates: args.templates,
+                processes: args.processes,
+                tools: args.tools,
+                frequentQuestions: args.frequent_questions,
+                results: args.results,
+                successExample: args.success_example,
+            });
+        case 'magnetlab_extract_content':
+            return client.extractContent(args.lead_magnet_id, {
+                archetype: args.archetype,
+                concept: args.concept,
+                answers: args.answers,
+            });
+        case 'magnetlab_generate_content':
+            return client.generateContent(args.lead_magnet_id, {
+                archetype: args.archetype,
+                concept: args.concept,
+                answers: args.answers,
+            });
+        case 'magnetlab_write_linkedin_posts':
+            return client.writeLinkedInPosts(args.lead_magnet_id, {
+                leadMagnetTitle: args.lead_magnet_title,
+                contents: args.contents,
+                problemSolved: args.problem_solved,
+            });
+        case 'magnetlab_polish_lead_magnet':
+            return client.polishLeadMagnetContent(args.lead_magnet_id);
+        case 'magnetlab_get_job_status':
+            return client.getJobStatus(args.job_id);
+        default:
+            throw new Error(`Unknown ideation tool: ${name}`);
+    }
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,24 @@
+import { MagnetLabClient } from '../client.js';
+export type ToolResult = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+};
+/**
+ * Main dispatcher for MCP tool calls.
+ * Routes tool calls to the appropriate category handler based on tool name.
+ * Validates required arguments before dispatching to handlers.
+ */
+export declare function handleToolCall(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<ToolResult>;
+export { handleLeadMagnetTools } from './lead-magnets.js';
+export { handleIdeationTools } from './ideation.js';
+export { handleFunnelTools } from './funnels.js';
+export { handleLeadTools } from './leads.js';
+export { handleAnalyticsTools } from './analytics.js';
+export { handleBrandKitTools } from './brand-kit.js';
+export { handleEmailSequenceTools } from './email-sequences.js';
+export { handleContentPipelineTools } from './content-pipeline.js';
+export { handleSwipeFileTools } from './swipe-file.js';
+export { handleLibraryTools } from './libraries.js';
+export { handleQualificationFormTools } from './qualification-forms.js';

package/dist/handlers/index.js

@@ -0,0 +1,104 @@
+import { handleLeadMagnetTools } from './lead-magnets.js';
+import { handleIdeationTools } from './ideation.js';
+import { handleFunnelTools } from './funnels.js';
+import { handleLeadTools } from './leads.js';
+import { handleAnalyticsTools } from './analytics.js';
+import { handleBrandKitTools } from './brand-kit.js';
+import { handleEmailSequenceTools } from './email-sequences.js';
+import { handleContentPipelineTools } from './content-pipeline.js';
+import { handleSwipeFileTools } from './swipe-file.js';
+import { handleLibraryTools } from './libraries.js';
+import { handleQualificationFormTools } from './qualification-forms.js';
+import { toolCategories } from '../tools/index.js';
+import { validateToolArgs } from '../validation.js';
+/**
+ * Main dispatcher for MCP tool calls.
+ * Routes tool calls to the appropriate category handler based on tool name.
+ * Validates required arguments before dispatching to handlers.
+ */
+export async function handleToolCall(name, args, client) {
+    try {
+        // Validate args before calling handler
+        const validation = validateToolArgs(name, args);
+        if (!validation.success) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ error: validation.error }),
+                    },
+                ],
+            };
+        }
+        let result;
+        // Route to appropriate handler based on tool category
+        if (toolCategories.leadMagnets.includes(name)) {
+            result = await handleLeadMagnetTools(name, args, client);
+        }
+        else if (toolCategories.ideation.includes(name)) {
+            result = await handleIdeationTools(name, args, client);
+        }
+        else if (toolCategories.funnels.includes(name)) {
+            result = await handleFunnelTools(name, args, client);
+        }
+        else if (toolCategories.leads.includes(name)) {
+            result = await handleLeadTools(name, args, client);
+        }
+        else if (toolCategories.analytics.includes(name)) {
+            result = await handleAnalyticsTools(name, args, client);
+        }
+        else if (toolCategories.brandKit.includes(name)) {
+            result = await handleBrandKitTools(name, args, client);
+        }
+        else if (toolCategories.emailSequences.includes(name)) {
+            result = await handleEmailSequenceTools(name, args, client);
+        }
+        else if (toolCategories.contentPipeline.includes(name)) {
+            result = await handleContentPipelineTools(name, args, client);
+        }
+        else if (toolCategories.swipeFile.includes(name)) {
+            result = await handleSwipeFileTools(name, args, client);
+        }
+        else if (toolCategories.libraries.includes(name)) {
+            result = await handleLibraryTools(name, args, client);
+        }
+        else if (toolCategories.qualificationForms.includes(name)) {
+            result = await handleQualificationFormTools(name, args, client);
+        }
+        else {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    }),
+                },
+            ],
+        };
+    }
+}
+// Re-export individual handlers for testing
+export { handleLeadMagnetTools } from './lead-magnets.js';
+export { handleIdeationTools } from './ideation.js';
+export { handleFunnelTools } from './funnels.js';
+export { handleLeadTools } from './leads.js';
+export { handleAnalyticsTools } from './analytics.js';
+export { handleBrandKitTools } from './brand-kit.js';
+export { handleEmailSequenceTools } from './email-sequences.js';
+export { handleContentPipelineTools } from './content-pipeline.js';
+export { handleSwipeFileTools } from './swipe-file.js';
+export { handleLibraryTools } from './libraries.js';
+export { handleQualificationFormTools } from './qualification-forms.js';

package/dist/handlers/lead-magnets.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle lead magnet related tool calls.
+ */
+export declare function handleLeadMagnetTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/lead-magnets.js

@@ -0,0 +1,31 @@
+/**
+ * Handle lead magnet related tool calls.
+ */
+export async function handleLeadMagnetTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_list_lead_magnets':
+            return client.listLeadMagnets({
+                status: args.status,
+                limit: args.limit,
+                offset: args.offset,
+            });
+        case 'magnetlab_get_lead_magnet':
+            return client.getLeadMagnet(args.id);
+        case 'magnetlab_create_lead_magnet':
+            return client.createLeadMagnet({
+                title: args.title,
+                archetype: args.archetype,
+                concept: args.concept,
+            });
+        case 'magnetlab_delete_lead_magnet':
+            return client.deleteLeadMagnet(args.id);
+        case 'magnetlab_get_lead_magnet_stats':
+            return client.getLeadMagnetStats(args.lead_magnet_id);
+        case 'magnetlab_analyze_competitor':
+            return client.analyzeCompetitor({ url: args.url });
+        case 'magnetlab_analyze_transcript':
+            return client.analyzeTranscript({ transcript: args.transcript });
+        default:
+            throw new Error(`Unknown lead magnet tool: ${name}`);
+    }
+}

package/dist/handlers/leads.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle lead management tool calls.
+ */
+export declare function handleLeadTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/leads.js

@@ -0,0 +1,24 @@
+/**
+ * Handle lead management tool calls.
+ */
+export async function handleLeadTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_list_leads':
+            return client.listLeads({
+                funnelId: args.funnel_id,
+                leadMagnetId: args.lead_magnet_id,
+                qualified: args.qualified,
+                search: args.search,
+                limit: args.limit,
+                offset: args.offset,
+            });
+        case 'magnetlab_export_leads':
+            return client.exportLeads({
+                funnelId: args.funnel_id,
+                leadMagnetId: args.lead_magnet_id,
+                qualified: args.qualified,
+            });
+        default:
+            throw new Error(`Unknown lead tool: ${name}`);
+    }
+}

package/dist/handlers/libraries.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle library tool calls.
+ */
+export declare function handleLibraryTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/libraries.js

@@ -0,0 +1,31 @@
+/**
+ * Handle library tool calls.
+ */
+export async function handleLibraryTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_list_libraries':
+            return client.listLibraries();
+        case 'magnetlab_get_library':
+            return client.getLibrary(args.id);
+        case 'magnetlab_create_library':
+            return client.createLibrary({
+                name: args.name,
+                description: args.description,
+            });
+        case 'magnetlab_update_library':
+            return client.updateLibrary(args.id, {
+                name: args.name,
+                description: args.description,
+            });
+        case 'magnetlab_delete_library':
+            return client.deleteLibrary(args.id);
+        case 'magnetlab_list_library_items':
+            return client.listLibraryItems(args.library_id);
+        case 'magnetlab_create_library_item': {
+            const { library_id, ...rest } = args;
+            return client.createLibraryItem(library_id, rest);
+        }
+        default:
+            throw new Error(`Unknown library tool: ${name}`);
+    }
+}

package/dist/handlers/qualification-forms.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle qualification form tool calls.
+ */
+export declare function handleQualificationFormTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/qualification-forms.js

@@ -0,0 +1,21 @@
+/**
+ * Handle qualification form tool calls.
+ */
+export async function handleQualificationFormTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_list_qualification_forms':
+            return client.listQualificationForms();
+        case 'magnetlab_get_qualification_form':
+            return client.getQualificationForm(args.id);
+        case 'magnetlab_create_qualification_form':
+            return client.createQualificationForm({ name: args.name });
+        case 'magnetlab_list_questions':
+            return client.listQuestions(args.form_id);
+        case 'magnetlab_create_question': {
+            const { form_id, ...rest } = args;
+            return client.createQuestion(form_id, rest);
+        }
+        default:
+            throw new Error(`Unknown qualification form tool: ${name}`);
+    }
+}

package/dist/handlers/swipe-file.d.ts

@@ -0,0 +1,5 @@
+import { MagnetLabClient } from '../client.js';
+/**
+ * Handle swipe file tool calls.
+ */
+export declare function handleSwipeFileTools(name: string, args: Record<string, unknown>, client: MagnetLabClient): Promise<unknown>;

package/dist/handlers/swipe-file.js

@@ -0,0 +1,31 @@
+/**
+ * Handle swipe file tool calls.
+ */
+export async function handleSwipeFileTools(name, args, client) {
+    switch (name) {
+        case 'magnetlab_browse_swipe_posts':
+            return client.browseSwipeFilePosts({
+                niche: args.niche,
+                type: args.type,
+                featured: args.featured,
+                limit: args.limit,
+                offset: args.offset,
+            });
+        case 'magnetlab_browse_swipe_lead_magnets':
+            return client.browseSwipeFileLeadMagnets({
+                niche: args.niche,
+                format: args.format,
+                featured: args.featured,
+                limit: args.limit,
+                offset: args.offset,
+            });
+        case 'magnetlab_submit_to_swipe_file':
+            return client.submitToSwipeFile({
+                content: args.content,
+                type: args.type,
+                niche: args.niche,
+            });
+        default:
+            throw new Error(`Unknown swipe file tool: ${name}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export * from './constants.js';
+export { MagnetLabClient } from './client.js';

package/dist/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Command } from 'commander';
+import { MagnetLabClient } from './client.js';
+import { tools } from './tools/index.js';
+import { handleToolCall } from './handlers/index.js';
+// Re-export constants and types for consumers
+export * from './constants.js';
+export { MagnetLabClient } from './client.js';
+async function startServer(apiKey, baseUrl) {
+    // Create the MagnetLab client
+    const client = new MagnetLabClient(apiKey, { baseUrl });
+    // Create the MCP server
+    const server = new Server({ name: 'magnetlab', version: '0.1.0' }, { capabilities: { tools: {} } });
+    // Register the tools list handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    // Register the tool call handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return handleToolCall(name, args || {}, client);
+    });
+    // Connect via stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+function resolveOptions(options) {
+    const apiKey = options.apiKey || process.env.MAGNETLAB_API_KEY;
+    if (!apiKey) {
+        console.error('Error: API key required. Set MAGNETLAB_API_KEY or use --api-key');
+        process.exit(1);
+    }
+    const baseUrl = options.baseUrl || process.env.MAGNETLAB_BASE_URL;
+    return { apiKey, baseUrl };
+}
+const program = new Command();
+program.name('magnetlab-mcp').description('MCP server for MagnetLab').version('0.1.0');
+program
+    .command('serve')
+    .description('Start the MCP server')
+    .option('--api-key <key>', 'MagnetLab API key')
+    .option('--base-url <url>', 'MagnetLab API base URL')
+    .action(async (options) => {
+    const { apiKey, baseUrl } = resolveOptions(options);
+    await startServer(apiKey, baseUrl);
+});
+// Default command (no subcommand) also starts the server for simplicity
+program
+    .option('--api-key <key>', 'MagnetLab API key')
+    .option('--base-url <url>', 'MagnetLab API base URL')
+    .action(async (options) => {
+    const { apiKey, baseUrl } = resolveOptions(options);
+    await startServer(apiKey, baseUrl);
+});
+program.parse();

package/dist/tools/analytics.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const analyticsTools: Tool[];