@capivv/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,124 @@
+# @capivv/mcp-server
+
+MCP (Model Context Protocol) server for the [Capivv](https://github.com/capivv/capivv) subscription management platform. Enables AI assistants like Claude, Cursor, and other MCP clients to manage your in-app subscription configuration.
+
+## Installation
+
+```sh
+# Run directly with npx (recommended)
+npx @capivv/mcp-server
+
+# Or install globally
+npm install -g @capivv/mcp-server
+capivv-mcp
+```
+
+## Configuration
+
+The server requires an API key from your Capivv dashboard.
+
+| Environment Variable | Required | Description |
+|---------------------|----------|-------------|
+| `CAPIVV_API_KEY` | Yes | API key from Settings > Developer > API Keys |
+| `CAPIVV_API_URL` | No | API base URL (default: `https://api.capivv.com`) |
+| `CAPIVV_ORG_ID` | No | Organization ID for multi-org accounts |
+
+## Setup
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "capivv": {
+      "command": "npx",
+      "args": ["-y", "@capivv/mcp-server"],
+      "env": {
+        "CAPIVV_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+**Config file location:**
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+### Claude Code
+
+```sh
+claude mcp add capivv -- npx -y @capivv/mcp-server
+```
+
+Set the API key in your environment or `.env` file:
+
+```sh
+export CAPIVV_API_KEY="your-api-key-here"
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "capivv": {
+      "command": "npx",
+      "args": ["-y", "@capivv/mcp-server"],
+      "env": {
+        "CAPIVV_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### Generic MCP Client
+
+The server uses stdio transport. Start it with:
+
+```sh
+CAPIVV_API_KEY=your-api-key npx @capivv/mcp-server
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `capivv_status` | Get setup progress, resource counts, and key metrics |
+| `capivv_list_apps` | List all apps with platform and bundle ID |
+| `capivv_list_products` | List products with store IDs and entitlements (optional `app_id` filter) |
+| `capivv_import_products` | Preview store product import from App Store Connect / Google Play |
+| `capivv_list_offerings` | List offerings with packages and products |
+| `capivv_create_offering` | Create a new offering with packages |
+| `capivv_list_rules` | List YAML business rules with status and priority |
+| `capivv_apply_rule` | Validate and apply a YAML rule configuration |
+| `capivv_list_experiments` | List A/B experiments with results and confidence |
+| `capivv_get_analytics` | Get MRR, ARR, churn rate, ARPU, and period comparison |
+
+## Available Resources
+
+| URI | Description |
+|-----|-------------|
+| `capivv://status` | Current platform status as JSON |
+| `capivv://rules/{ruleId}` | Individual rule YAML content |
+| `capivv://docs/concepts` | Glossary of subscription platform concepts |
+
+## Troubleshooting
+
+**"CAPIVV_API_KEY is required"**
+Set the `CAPIVV_API_KEY` environment variable. Get your API key from the Capivv dashboard under Settings > Developer > API Keys.
+
+**Tools not appearing in Claude Desktop**
+Restart Claude Desktop after updating `claude_desktop_config.json`. Check the MCP logs for errors.
+
+**Connection errors**
+Verify your API key is valid and your network can reach the Capivv API. If using a custom `CAPIVV_API_URL`, ensure the URL is correct.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,31 @@
+import type { Config } from './config.js';
+import type { App, Product, Entitlement, Offering, Rule, Experiment, ExperimentSummary, AnalyticsOverview, OnboardingResponse, ImportPreviewResponse, CreateOfferingRequest, CreateRuleRequest, ValidateRuleResponse } from './types.js';
+export declare class ApiError extends Error {
+    status: number;
+    code: string;
+    details?: Record<string, unknown> | undefined;
+    constructor(status: number, code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+export declare class CapivvClient {
+    private baseUrl;
+    private headers;
+    constructor(config: Config);
+    private request;
+    private get;
+    private post;
+    healthCheck(): Promise<boolean>;
+    listApps(): Promise<App[]>;
+    listProducts(appId?: string): Promise<Product[]>;
+    listEntitlements(): Promise<Entitlement[]>;
+    listOfferings(): Promise<Offering[]>;
+    createOffering(data: CreateOfferingRequest): Promise<Offering>;
+    listRules(): Promise<Rule[]>;
+    getRule(id: string): Promise<Rule>;
+    upsertRule(data: CreateRuleRequest): Promise<Rule>;
+    validateRule(content: string): Promise<ValidateRuleResponse>;
+    listExperiments(): Promise<Experiment[]>;
+    getExperimentSummaries(): Promise<ExperimentSummary[]>;
+    getAnalyticsOverview(): Promise<AnalyticsOverview>;
+    getOnboarding(): Promise<OnboardingResponse>;
+    getImportPreview(appId: string): Promise<ImportPreviewResponse>;
+}

package/dist/client.js

@@ -0,0 +1,113 @@
+export class ApiError extends Error {
+    status;
+    code;
+    details;
+    constructor(status, code, message, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
+        this.name = 'ApiError';
+    }
+}
+export class CapivvClient {
+    baseUrl;
+    headers;
+    constructor(config) {
+        this.baseUrl = `${config.apiUrl}/v1`;
+        this.headers = {
+            Authorization: `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+            ...(config.orgId ? { 'X-Organization-ID': config.orgId } : {}),
+        };
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const options = {
+            method,
+            headers: this.headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        };
+        let response;
+        try {
+            response = await fetch(url, options);
+        }
+        catch (err) {
+            throw new ApiError(0, 'network_error', `Failed to connect to Capivv API at ${this.baseUrl}: ${err.message}`);
+        }
+        if (!response.ok) {
+            const errorBody = await response.json().catch(() => ({}));
+            const err = errorBody?.error;
+            throw new ApiError(response.status, err?.code ?? 'unknown', err?.message ?? `API request failed: ${response.status} ${response.statusText}`, err?.details);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return response.json();
+    }
+    get(path) {
+        return this.request('GET', path);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+    async healthCheck() {
+        try {
+            await this.get('/health');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async listApps() {
+        const resp = await this.get('/dashboard/apps');
+        return resp.apps;
+    }
+    async listProducts(appId) {
+        const path = appId ? `/dashboard/products?app_id=${encodeURIComponent(appId)}` : '/dashboard/products';
+        const resp = await this.get(path);
+        return resp.products;
+    }
+    async listEntitlements() {
+        const resp = await this.get('/dashboard/entitlements');
+        return resp.entitlements;
+    }
+    async listOfferings() {
+        const resp = await this.get('/dashboard/offerings');
+        return resp.offerings;
+    }
+    async createOffering(data) {
+        return this.post('/dashboard/offerings', data);
+    }
+    async listRules() {
+        const resp = await this.get('/dashboard/rules');
+        return resp.rules;
+    }
+    async getRule(id) {
+        return this.get(`/dashboard/rules/${encodeURIComponent(id)}`);
+    }
+    async upsertRule(data) {
+        return this.post('/dashboard/rules', data);
+    }
+    async validateRule(content) {
+        return this.post('/dashboard/rules/validate', { content });
+    }
+    async listExperiments() {
+        const resp = await this.get('/dashboard/experiments/active');
+        return resp.experiments;
+    }
+    async getExperimentSummaries() {
+        const resp = await this.get('/dashboard/experiments/summaries');
+        return resp.summaries;
+    }
+    async getAnalyticsOverview() {
+        return this.get('/dashboard/analytics/overview');
+    }
+    async getOnboarding() {
+        return this.get('/dashboard/onboarding');
+    }
+    async getImportPreview(appId) {
+        return this.get(`/dashboard/onboarding/import-preview?app_id=${encodeURIComponent(appId)}`);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+export interface Config {
+    apiKey: string;
+    apiUrl: string;
+    orgId: string | undefined;
+}
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,16 @@
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+export function loadConfig() {
+    const apiKey = process.env.CAPIVV_API_KEY;
+    if (!apiKey) {
+        throw new ConfigError('CAPIVV_API_KEY environment variable is required. ' +
+            'Create an API key in the Capivv dashboard under Settings > Developer > API Keys.');
+    }
+    const apiUrl = (process.env.CAPIVV_API_URL || 'https://api.capivv.com').replace(/\/+$/, '');
+    const orgId = process.env.CAPIVV_ORG_ID || undefined;
+    return { apiKey, apiUrl, orgId };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadConfig, ConfigError } from './config.js';
+import { createServer } from './server.js';
+async function main() {
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        if (err instanceof ConfigError) {
+            console.error(`[capivv-mcp] ${err.message}`);
+            process.exit(1);
+        }
+        throw err;
+    }
+    const server = createServer(config);
+    const transport = new StdioServerTransport();
+    process.on('SIGINT', async () => {
+        await server.close();
+        process.exit(0);
+    });
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error('[capivv-mcp] Fatal error:', err);
+    process.exit(1);
+});

package/dist/resources/concepts.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+interface Concept {
+    term: string;
+    definition: string;
+    relatedTerms: string[];
+}
+declare const CONCEPTS: Concept[];
+export declare function registerConceptsResource(server: McpServer): void;
+export { CONCEPTS };

package/dist/resources/concepts.js

@@ -0,0 +1,92 @@
+// Capivv platform concepts — mirrored from dashboard/src/lib/knowledge-base.ts GLOSSARY
+const CONCEPTS = [
+    {
+        term: 'App',
+        definition: "A platform-specific application (iOS, Android, or Web) registered in Capivv. Each app has a unique Bundle ID and connects to a specific app store.",
+        relatedTerms: ['Bundle ID', 'Product'],
+    },
+    {
+        term: 'Bundle ID',
+        definition: "Your app's unique identifier (e.g. com.company.app). Must match the identifier registered in App Store Connect or Google Play Console.",
+        relatedTerms: ['App'],
+    },
+    {
+        term: 'Entitlement',
+        definition: "A feature or capability users can access (e.g. 'premium', 'no_ads'). Entitlements are granted when a user purchases a product that includes them.",
+        relatedTerms: ['Product', 'Offering'],
+    },
+    {
+        term: 'Experiment',
+        definition: 'An A/B test that compares different paywalls, prices, or offerings to find what converts best. Results include statistical confidence metrics.',
+        relatedTerms: ['Paywall', 'Offering'],
+    },
+    {
+        term: 'Offering',
+        definition: 'A bundle of products presented to users. Your paywall displays the current offering. Each offering contains one or more packages.',
+        relatedTerms: ['Package', 'Product', 'Paywall'],
+    },
+    {
+        term: 'Package',
+        definition: "A single purchase option within an offering (e.g. 'Monthly' or 'Annual' plan). Each package maps to a product.",
+        relatedTerms: ['Offering', 'Product'],
+    },
+    {
+        term: 'Paywall',
+        definition: 'A customizable screen presented to users when they hit a premium feature. Paywalls display your offering and drive purchase conversions.',
+        relatedTerms: ['Offering', 'Experiment'],
+    },
+    {
+        term: 'Product',
+        definition: 'A purchasable item from App Store or Play Store. Products link to the entitlements they grant when purchased.',
+        relatedTerms: ['Entitlement', 'Offering', 'Subscription'],
+    },
+    {
+        term: 'Promotion',
+        definition: 'A time-limited campaign offering discounts, extended trials, or special deals to targeted user segments.',
+        relatedTerms: ['Rule', 'Experiment'],
+    },
+    {
+        term: 'Public Key',
+        definition: 'An API key used in your mobile/web app to authenticate SDK calls. Safe to include in client-side code.',
+        relatedTerms: ['Secret Key'],
+    },
+    {
+        term: 'Rescue Flow',
+        definition: 'An automated workflow triggered when a user tries to cancel their subscription. Presents save offers to reduce churn.',
+        relatedTerms: ['Promotion', 'Subscription'],
+    },
+    {
+        term: 'Rule',
+        definition: 'A YAML-based condition that controls pricing, targeting, or churn recovery. Rules evaluate user attributes and trigger actions like discounts or paywall changes.',
+        relatedTerms: ['Promotion', 'Experiment'],
+    },
+    {
+        term: 'Secret Key',
+        definition: 'An API key used on your backend server for admin operations like managing users and subscriptions. Never expose to client code.',
+        relatedTerms: ['Public Key'],
+    },
+    {
+        term: 'Subscription',
+        definition: 'A recurring purchase that grants entitlements for a billing period. Subscriptions can be monthly, annual, or custom intervals.',
+        relatedTerms: ['Product', 'Entitlement'],
+    },
+    {
+        term: 'Webhook',
+        definition: 'An HTTP callback sent to your server when events occur in Capivv (purchases, cancellations, renewals, etc.). Used to keep your backend in sync.',
+        relatedTerms: ['Subscription'],
+    },
+];
+export function registerConceptsResource(server) {
+    server.resource('concepts', 'capivv://docs/concepts', { mimeType: 'application/json' }, async (uri) => {
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: JSON.stringify(CONCEPTS, null, 2),
+                },
+            ],
+        };
+    });
+}
+// Exported for tests
+export { CONCEPTS };

package/dist/resources/index.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerAllResources(server: McpServer, client: CapivvClient): void;

package/dist/resources/index.js

@@ -0,0 +1,8 @@
+import { registerStatusResource } from './status.js';
+import { registerRulesResource } from './rules.js';
+import { registerConceptsResource } from './concepts.js';
+export function registerAllResources(server, client) {
+    registerStatusResource(server, client);
+    registerRulesResource(server, client);
+    registerConceptsResource(server);
+}

package/dist/resources/rules.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerRulesResource(server: McpServer, client: CapivvClient): void;

package/dist/resources/rules.js

@@ -0,0 +1,27 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+export function registerRulesResource(server, client) {
+    server.resource('rule', new ResourceTemplate('capivv://rules/{ruleId}', {
+        list: async () => {
+            const rules = await client.listRules();
+            return {
+                resources: rules.map((r) => ({
+                    uri: `capivv://rules/${r.id}`,
+                    name: r.name,
+                    description: `Rule: ${r.name} (priority: ${r.priority}, ${r.is_enabled ? 'enabled' : 'disabled'})`,
+                    mimeType: 'text/yaml',
+                })),
+            };
+        },
+    }), { mimeType: 'text/yaml' }, async (uri, { ruleId }) => {
+        const id = Array.isArray(ruleId) ? ruleId[0] : ruleId;
+        const rule = await client.getRule(id);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: rule.content,
+                },
+            ],
+        };
+    });
+}

package/dist/resources/status.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerStatusResource(server: McpServer, client: CapivvClient): void;

package/dist/resources/status.js

@@ -0,0 +1,43 @@
+export function registerStatusResource(server, client) {
+    server.resource('status', 'capivv://status', { mimeType: 'application/json' }, async (uri) => {
+        const [apps, products, entitlements, offerings, rules, onboarding, analytics] = await Promise.allSettled([
+            client.listApps(),
+            client.listProducts(),
+            client.listEntitlements(),
+            client.listOfferings(),
+            client.listRules(),
+            client.getOnboarding(),
+            client.getAnalyticsOverview(),
+        ]);
+        const count = (r) => r.status === 'fulfilled' ? r.value.length : 0;
+        const result = {
+            resources: {
+                apps: count(apps),
+                products: count(products),
+                entitlements: count(entitlements),
+                offerings: count(offerings),
+                rules: count(rules),
+            },
+        };
+        if (onboarding.status === 'fulfilled') {
+            const ob = onboarding.value;
+            result.onboarding = {
+                is_complete: ob.is_complete,
+                completed_steps: ob.completed_steps,
+                total_steps: ob.total_steps,
+                next_step: ob.next_step,
+            };
+        }
+        if (analytics.status === 'fulfilled') {
+            const a = analytics.value;
+            result.analytics = {
+                mrr: a.mrr_formatted,
+                arr: a.arr_formatted,
+                active_subscriptions: a.active_subscriptions,
+                churn_rate: a.churn_rate,
+                arpu: a.arpu_formatted,
+            };
+        }
+        return { contents: [{ uri: uri.href, text: JSON.stringify(result, null, 2) }] };
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Config } from './config.js';
+export declare function createServer(config: Config): McpServer;

package/dist/server.js

@@ -0,0 +1,11 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { CapivvClient } from './client.js';
+import { registerAllTools } from './tools/index.js';
+import { registerAllResources } from './resources/index.js';
+export function createServer(config) {
+    const server = new McpServer({ name: 'capivv-mcp', version: '0.1.0' }, { capabilities: { logging: {} } });
+    const client = new CapivvClient(config);
+    registerAllTools(server, client);
+    registerAllResources(server, client);
+    return server;
+}

package/dist/tools/apply-rule.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerApplyRuleTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/apply-rule.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export function registerApplyRuleTool(server, client) {
+    server.tool('capivv_apply_rule', 'Apply a YAML rule configuration. Validates the rule first, then creates or updates it. Returns validation errors if the YAML is invalid.', {
+        name: z.string().describe('Rule name'),
+        content: z.string().describe('YAML rule content'),
+        priority: z.number().optional().default(100).describe('Rule priority (lower = higher priority)'),
+        is_enabled: z.boolean().optional().default(true).describe('Whether the rule is active'),
+    }, async ({ name, content, priority, is_enabled }) => {
+        // Validate first
+        const validation = await client.validateRule(content);
+        if (!validation.is_valid) {
+            const result = {
+                success: false,
+                validation_errors: validation.errors,
+                validation_warnings: validation.warnings,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: true,
+            };
+        }
+        // Create/update the rule
+        const rule = await client.upsertRule({ name, content, priority, is_enabled });
+        const result = {
+            success: true,
+            rule: {
+                id: rule.id,
+                name: rule.name,
+                priority: rule.priority,
+                is_enabled: rule.is_enabled,
+                updated_at: rule.updated_at,
+            },
+            validation_warnings: validation.warnings.length > 0 ? validation.warnings : undefined,
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+}

package/dist/tools/create-offering.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerCreateOfferingTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/create-offering.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export function registerCreateOfferingTool(server, client) {
+    server.tool('capivv_create_offering', 'Create a new offering to bundle products for your paywall. Specify products and their display order.', {
+        app_id: z.string().describe('App ID this offering belongs to'),
+        identifier: z.string().describe('Unique identifier (e.g., "default", "premium_monthly")'),
+        display_name: z.string().describe('Human-readable name shown in the dashboard'),
+        description: z.string().optional().describe('Optional description'),
+        is_default: z.boolean().optional().describe('Whether this is the default offering'),
+        packages: z
+            .array(z.object({
+            identifier: z.string().describe('Package identifier (e.g., "$rc_monthly")'),
+            product_id: z.string().describe('Product ID to include'),
+            display_name: z.string().describe('Display name for this package'),
+            package_type: z
+                .string()
+                .describe('One of: monthly, annual, weekly, lifetime, custom'),
+            position: z.number().describe('Display order (0-based)'),
+        }))
+            .describe('Products to include in this offering'),
+    }, async (args) => {
+        const offering = await client.createOffering(args);
+        return { content: [{ type: 'text', text: JSON.stringify(offering, null, 2) }] };
+    });
+}

package/dist/tools/get-analytics.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerGetAnalyticsTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/get-analytics.js

@@ -0,0 +1,29 @@
+export function registerGetAnalyticsTool(server, client) {
+    server.tool('capivv_get_analytics', 'Get key subscription business metrics: MRR, ARR, active subscriptions, churn rate, ARPU, and period-over-period comparison.', async () => {
+        const overview = await client.getAnalyticsOverview();
+        const result = {
+            revenue: {
+                mrr: overview.mrr_formatted,
+                arr: overview.arr_formatted,
+                arpu: overview.arpu_formatted,
+            },
+            subscriptions: {
+                active: overview.active_subscriptions,
+                trialing: overview.trialing_subscriptions,
+                churn_rate: `${overview.churn_rate}%`,
+            },
+        };
+        if (overview.period_comparison) {
+            result.period_comparison = {
+                mrr_change: `${overview.period_comparison.mrr_change_percent >= 0 ? '+' : ''}${overview.period_comparison.mrr_change_percent}%`,
+                subscriptions_change: `${overview.period_comparison.subscriptions_change_percent >= 0 ? '+' : ''}${overview.period_comparison.subscriptions_change_percent}%`,
+            };
+        }
+        // E.4.3: Explain zero metrics and suggest next steps
+        if (overview.active_subscriptions === 0 && overview.trialing_subscriptions === 0) {
+            result._suggestion =
+                'No subscription data yet. This is normal for new setups. To start seeing metrics: 1) Create products and offerings, 2) Integrate the SDK in your app, 3) Make a test purchase in sandbox mode.';
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+}

package/dist/tools/import-products.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CapivvClient } from '../client.js';
+export declare function registerImportProductsTool(server: McpServer, client: CapivvClient): void;