@capivv/mcp-server 0.1.3 → 0.2.0

package/README.md

@@ -20,7 +20,7 @@ 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_API_URL` | No | API base URL (default: `https://app.capivv.com`) |
 | `CAPIVV_ORG_ID` | No | Organization ID for multi-org accounts |
 
 ## Setup
@@ -85,25 +85,96 @@ The server uses stdio transport. Start it with:
 CAPIVV_API_KEY=your-api-key npx @capivv/mcp-server
 ```
 
+## Getting Started
+
+After installing, ask your AI assistant:
+
+> "Set up Capivv for my iOS app com.mycompany.myapp with a monthly ($7.99) and annual ($49.99) subscription"
+
+The assistant will use `capivv_setup_wizard` to create everything in one shot. Or go step-by-step:
+
+1. **`capivv_next_step`** — tells you exactly what to do next based on your current setup
+2. **`capivv_setup_wizard`** — creates app + entitlement + products + offering in one call
+3. **`capivv_verify_setup`** — checks everything is configured correctly
+
+Read the `capivv://docs/quickstart` resource for a full walkthrough.
+
 ## Available Tools
 
+### Identity
+
+| Tool | Description |
+|------|-------------|
+| `capivv_whoami` | Show which workspace (org) and apps your API key reaches. Call this first if anything looks wrong |
+
+### Onboarding & Guidance
+
+| Tool | Description |
+|------|-------------|
+| `capivv_next_step` | Analyze your setup and get exact instructions for the next step |
+| `capivv_setup_wizard` | One-shot setup: app + entitlement + products + offering in one call |
+| `capivv_verify_setup` | Pass/fail checklist verifying your entire setup with fix instructions |
+
+### Status & Analytics
+
 | Tool | Description |
 |------|-------------|
 | `capivv_status` | Get setup progress, resource counts, and key metrics |
+| `capivv_get_analytics` | Get MRR, ARR, churn rate, ARPU, and period comparison |
+
+### Apps
+
+| Tool | Description |
+|------|-------------|
 | `capivv_list_apps` | List all apps with platform and bundle ID |
+| `capivv_create_app` | Register a new app (iOS, Android, or Web) |
+
+### Entitlements
+
+| Tool | Description |
+|------|-------------|
+| `capivv_list_entitlements` | List all entitlements (feature access identifiers) |
+| `capivv_create_entitlement` | Create a new entitlement |
+
+### Products
+
+| Tool | Description |
+|------|-------------|
 | `capivv_list_products` | List products with store IDs and entitlements (optional `app_id` filter) |
+| `capivv_create_product` | Create a subscription, consumable, or non-consumable product |
+| `capivv_update_product` | Update product fields (name, entitlements, external ID) |
+| `capivv_delete_product` | Delete a product (irreversible) |
 | `capivv_import_products` | Preview store product import from App Store Connect / Google Play |
+
+### Offerings
+
+| Tool | Description |
+|------|-------------|
 | `capivv_list_offerings` | List offerings with packages and products |
 | `capivv_create_offering` | Create a new offering with packages |
+
+### Rules
+
+| Tool | Description |
+|------|-------------|
 | `capivv_list_rules` | List YAML business rules with status and priority |
 | `capivv_apply_rule` | Validate and apply a YAML rule configuration |
+| `capivv_activate_rule` | Activate an existing rule |
+| `capivv_delete_rule` | Delete a rule (irreversible) |
+
+### Experiments
+
+| Tool | Description |
+|------|-------------|
 | `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://docs/quickstart` | Step-by-step setup guide — **start here** |
+| `capivv://docs/guides/ios` | Complete iOS integration guide with code examples |
+| `capivv://docs/guides/ai-prompts` | Ready-to-use prompts for AI code generators (Lovable, Bolt, Cursor) |
 | `capivv://status` | Current platform status as JSON |
 | `capivv://rules/{ruleId}` | Individual rule YAML content |
 | `capivv://docs/concepts` | Glossary of subscription platform concepts |

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from './config.js';
-import type { App, Product, Entitlement, Offering, Rule, Experiment, ExperimentSummary, AnalyticsOverview, OnboardingResponse, ImportPreviewResponse, CreateOfferingRequest, CreateRuleRequest, ValidateRuleResponse } from './types.js';
+import type { App, Product, Entitlement, Offering, Rule, Experiment, ExperimentSummary, AnalyticsOverview, OnboardingResponse, ImportPreviewResponse, CreateAppRequest, CreateEntitlementRequest, CreateProductRequest, CreateOfferingRequest, CreateRuleRequest, ValidateRuleRequest, ValidateRuleResponse, WhoamiResponse, ApiKeyUsageResponse } from './types.js';
 export declare class ApiError extends Error {
     status: number;
     code: string;
@@ -14,6 +14,8 @@ export declare class CapivvClient {
     private get;
     private post;
     healthCheck(): Promise<boolean>;
+    whoami(): Promise<WhoamiResponse>;
+    getApiKeyUsage(apiKeyId: string, hours?: number): Promise<ApiKeyUsageResponse>;
     listApps(): Promise<App[]>;
     listProducts(appId?: string): Promise<Product[]>;
     listEntitlements(): Promise<Entitlement[]>;
@@ -21,11 +23,21 @@ export declare class CapivvClient {
     createOffering(data: CreateOfferingRequest): Promise<Offering>;
     listRules(): Promise<Rule[]>;
     getRule(id: string): Promise<Rule>;
-    upsertRule(data: CreateRuleRequest): Promise<Rule>;
-    validateRule(content: string): Promise<ValidateRuleResponse>;
+    createRule(data: CreateRuleRequest): Promise<Rule>;
+    validateRule(data: ValidateRuleRequest): Promise<ValidateRuleResponse>;
     listExperiments(): Promise<Experiment[]>;
     getExperimentSummaries(): Promise<ExperimentSummary[]>;
     getAnalyticsOverview(): Promise<AnalyticsOverview>;
     getOnboarding(): Promise<OnboardingResponse>;
     getImportPreview(appId: string): Promise<ImportPreviewResponse>;
+    createApp(data: CreateAppRequest): Promise<App>;
+    createEntitlement(data: CreateEntitlementRequest): Promise<Entitlement>;
+    createProduct(data: CreateProductRequest): Promise<Product>;
+    private patch;
+    private delete;
+    updateProduct(id: string, data: Partial<Omit<CreateProductRequest, 'app_id'>>): Promise<Product>;
+    deleteProduct(id: string): Promise<void>;
+    deleteRule(id: string): Promise<void>;
+    activateRule(id: string): Promise<Rule>;
+    deactivateRule(id: string): Promise<Rule>;
 }

package/dist/client.js

@@ -53,13 +53,21 @@ export class CapivvClient {
     }
     async healthCheck() {
         try {
-            await this.get('/health');
-            return true;
+            // Health endpoint is at root, not under /v1
+            const url = this.baseUrl.replace(/\/v1$/, '') + '/health';
+            const response = await fetch(url);
+            return response.ok;
         }
         catch {
             return false;
         }
     }
+    async whoami() {
+        return this.get('/dashboard/whoami');
+    }
+    async getApiKeyUsage(apiKeyId, hours = 24) {
+        return this.get(`/dashboard/settings/api-keys/${encodeURIComponent(apiKeyId)}/usage?hours=${hours}`);
+    }
     async listApps() {
         const resp = await this.get('/dashboard/apps');
         return resp.apps;
@@ -87,11 +95,11 @@ export class CapivvClient {
     async getRule(id) {
         return this.get(`/dashboard/rules/${encodeURIComponent(id)}`);
     }
-    async upsertRule(data) {
+    async createRule(data) {
         return this.post('/dashboard/rules', data);
     }
-    async validateRule(content) {
-        return this.post('/dashboard/rules/validate', { content });
+    async validateRule(data) {
+        return this.post('/dashboard/rules/validate', data);
     }
     async listExperiments() {
         const resp = await this.get('/dashboard/experiments/active');
@@ -110,4 +118,36 @@ export class CapivvClient {
     async getImportPreview(appId) {
         return this.get(`/dashboard/onboarding/import-preview?app_id=${encodeURIComponent(appId)}`);
     }
+    // ---- Create methods ----
+    async createApp(data) {
+        return this.post('/dashboard/apps', data);
+    }
+    async createEntitlement(data) {
+        return this.post('/dashboard/entitlements', data);
+    }
+    async createProduct(data) {
+        return this.post('/dashboard/products', data);
+    }
+    // ---- Update methods ----
+    patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    delete(path) {
+        return this.request('DELETE', path);
+    }
+    async updateProduct(id, data) {
+        return this.patch(`/dashboard/products/${encodeURIComponent(id)}`, data);
+    }
+    async deleteProduct(id) {
+        await this.delete(`/dashboard/products/${encodeURIComponent(id)}`);
+    }
+    async deleteRule(id) {
+        await this.delete(`/dashboard/rules/${encodeURIComponent(id)}`);
+    }
+    async activateRule(id) {
+        return this.post(`/dashboard/rules/${encodeURIComponent(id)}/activate`);
+    }
+    async deactivateRule(id) {
+        return this.post(`/dashboard/rules/${encodeURIComponent(id)}/deactivate`);
+    }
 }

package/dist/config.js

@@ -10,7 +10,7 @@ export function loadConfig() {
         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 apiUrl = (process.env.CAPIVV_API_URL || 'https://app.capivv.com').replace(/\/+$/, '');
     const orgId = process.env.CAPIVV_ORG_ID || undefined;
     return { apiKey, apiUrl, orgId };
 }

package/dist/http.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * MCP Remote HTTP Server
+ *
+ * Exposes the Capivv MCP server over Streamable HTTP transport.
+ * Clients authenticate with their Capivv API key as a Bearer token.
+ *
+ * Usage in Lovable / other MCP clients:
+ *   Server URL: https://app.capivv.com/mcp
+ *   Auth: Bearer token → paste your Capivv secret API key
+ */
+export {};

package/dist/http.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * MCP Remote HTTP Server
+ *
+ * Exposes the Capivv MCP server over Streamable HTTP transport.
+ * Clients authenticate with their Capivv API key as a Bearer token.
+ *
+ * Usage in Lovable / other MCP clients:
+ *   Server URL: https://app.capivv.com/mcp
+ *   Auth: Bearer token → paste your Capivv secret API key
+ */
+import express from 'express';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createServer } from './server.js';
+const PORT = parseInt(process.env.MCP_PORT || '3100', 10);
+const HOST = process.env.MCP_HOST || '0.0.0.0';
+const API_URL = (process.env.CAPIVV_API_URL || 'https://app.capivv.com').replace(/\/+$/, '');
+const app = express();
+app.use(express.json());
+// Health check
+app.get('/health', (_req, res) => {
+    res.json({ status: 'ok', service: 'capivv-mcp' });
+});
+// Public origin used in the WWW-Authenticate header so OAuth-aware MCP clients
+// (Cursor, Claude Desktop) can discover our authorization server. Falls back to
+// CAPIVV_API_URL because in production the MCP and API share the same hostname
+// behind Caddy.
+const PUBLIC_URL = (process.env.CAPIVV_PUBLIC_URL || API_URL).replace(/\/+$/, '');
+function unauthorized(res, description) {
+    // RFC 9728: point the client at the protected-resource metadata so it can
+    // discover our authorization server and start the OAuth flow.
+    res.setHeader('WWW-Authenticate', `Bearer realm="capivv-mcp", error="invalid_token", error_description="${description}", resource_metadata="${PUBLIC_URL}/.well-known/oauth-protected-resource"`);
+    res.status(401).json({
+        jsonrpc: '2.0',
+        error: { code: -32000, message: description },
+        id: null,
+    });
+}
+// MCP endpoint — Streamable HTTP
+app.post('/mcp', async (req, res) => {
+    try {
+        // Extract API key from Authorization header
+        const authHeader = req.headers.authorization;
+        if (!authHeader) {
+            unauthorized(res, 'Missing Authorization header. Sign in via your MCP client or set Bearer <your-capivv-api-key>.');
+            return;
+        }
+        const apiKey = authHeader.startsWith('Bearer ')
+            ? authHeader.slice(7).trim()
+            : authHeader.trim();
+        if (!apiKey) {
+            unauthorized(res, 'Empty bearer token.');
+            return;
+        }
+        // Create a config using the client's API key
+        const config = {
+            apiKey,
+            apiUrl: API_URL,
+            orgId: undefined,
+        };
+        // Create a fresh server + transport per request (stateless)
+        const server = createServer(config);
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined, // stateless — no session tracking
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch (error) {
+        console.error('[mcp-http] Error handling request:', error);
+        if (!res.headersSent) {
+            res.status(500).json({
+                jsonrpc: '2.0',
+                error: { code: -32603, message: 'Internal server error' },
+                id: null,
+            });
+        }
+    }
+});
+// Handle GET for SSE streams (server-initiated messages)
+app.get('/mcp', async (_req, res) => {
+    // In stateless mode, we don't support server-initiated SSE
+    res.status(405).json({
+        jsonrpc: '2.0',
+        error: { code: -32000, message: 'Server-initiated SSE not supported in stateless mode. Use POST.' },
+        id: null,
+    });
+});
+// Handle DELETE for session termination
+app.delete('/mcp', async (_req, res) => {
+    // Stateless — no sessions to terminate
+    res.status(405).json({
+        jsonrpc: '2.0',
+        error: { code: -32000, message: 'No sessions to terminate (stateless server).' },
+        id: null,
+    });
+});
+app.listen(PORT, HOST, () => {
+    console.log(`[capivv-mcp] HTTP server listening on http://${HOST}:${PORT}/mcp`);
+    console.log(`[capivv-mcp] API URL: ${API_URL}`);
+    console.log(`[capivv-mcp] Auth: Bearer token (use your Capivv API key)`);
+});

package/dist/resources/guides.d.ts

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

package/dist/resources/guides.js

@@ -0,0 +1,81 @@
+import { readFile } from 'fs/promises';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Resolve path to the docs/ directory relative to the package root
+function docsDir() {
+    // packages/mcp-server/src/resources/guides.ts → packages/mcp-server/
+    const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+    // packages/mcp-server/ → project root docs/
+    return resolve(packageRoot, '..', '..', 'docs');
+}
+const GUIDES = [
+    {
+        name: 'guide-ios',
+        uri: 'capivv://docs/guides/ios',
+        file: 'IOS_INTEGRATION_GUIDE.md',
+        description: 'Step-by-step iOS integration guide: App Store Connect setup, SDK installation, purchases, entitlements, testing, and troubleshooting.',
+    },
+    {
+        name: 'guide-ai-prompts',
+        uri: 'capivv://docs/guides/ai-prompts',
+        file: 'AI_INTEGRATION_PROMPTS.md',
+        description: 'Ready-to-use prompts for AI code generators (Lovable, Bolt, Cursor) to integrate Capivv on iOS, Android, Flutter, Web, and Ionic.',
+    },
+];
+// Fallback content if the file can't be read (e.g., when running from npm package without docs/)
+const FALLBACK = {
+    'IOS_INTEGRATION_GUIDE.md': `# iOS Integration Guide
+
+This guide is available at https://docs.capivv.com/guides/ios
+
+## Quick Steps
+
+1. **App Store Connect**: Create subscription products, set pricing, enable Server Notifications V2 pointing to \`https://app.capivv.com/v1/webhooks/apple\`
+2. **Capivv Dashboard**: Create app (iOS, your bundle ID), create entitlements (e.g., "pro"), create products matching your store IDs, link products to entitlements
+3. **Install SDK**: Add \`https://github.com/capivv/capivv-ios\` via Swift Package Manager
+4. **Initialize**: Call \`Capivv.shared.configure(apiKey: "capivv_pk_...")\` in your App.init()
+5. **Identify users**: Call \`Capivv.shared.login(userId: "...")\` after authentication
+6. **Check entitlements**: Use \`Capivv.shared.hasEntitlement("pro")\` to gate features
+7. **Show paywall**: Use \`PaywallView(identifier: "default")\` or build a custom one with \`Capivv.shared.getOfferings()\`
+8. **Test**: Use StoreKit Configuration files in Xcode, sandbox Apple IDs
+
+For the full guide with code examples, read capivv://docs/quickstart or visit https://docs.capivv.com/guides/ios`,
+    'AI_INTEGRATION_PROMPTS.md': `# AI Integration Prompts
+
+Ready-to-use prompts for AI code generators are available at https://docs.capivv.com/guides/ai-prompts
+
+Supported platforms: iOS (Swift), Android (Kotlin), Flutter, Web (React), Ionic/Capacitor
+
+For each platform, the prompt covers:
+1. SDK installation
+2. Initialization with API key
+3. User identification
+4. Entitlement checking
+5. Paywall display
+6. Purchase processing
+7. Sync on launch
+
+Visit https://docs.capivv.com/guides/ai-prompts for the full prompts.`,
+};
+export function registerGuideResources(server) {
+    for (const guide of GUIDES) {
+        server.resource(guide.name, guide.uri, { mimeType: 'text/markdown' }, async (uri) => {
+            let content;
+            try {
+                const filePath = resolve(docsDir(), guide.file);
+                content = await readFile(filePath, 'utf-8');
+            }
+            catch {
+                content = FALLBACK[guide.file] ?? `Guide not found. Visit https://docs.capivv.com for documentation.`;
+            }
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: content,
+                    },
+                ],
+            };
+        });
+    }
+}

package/dist/resources/index.js

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

package/dist/resources/quickstart.d.ts

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

package/dist/resources/quickstart.js

@@ -0,0 +1,173 @@
+const QUICKSTART_GUIDE = `# Capivv Quickstart Guide
+
+Get your app's subscriptions working in 5 steps. Follow them **in order** — each step depends on the previous one.
+
+---
+
+## Step 1: Register Your App
+
+Every app needs to be registered in Capivv with its platform and bundle ID.
+
+**Tool:** \`capivv_create_app\`
+**Example:**
+- name: "My App"
+- platform: "ios" (or "android", "web")
+- bundle_id: "com.yourcompany.yourapp"
+
+**Save the returned \`id\`** — you'll need it for products and offerings.
+
+---
+
+## Step 2: Create Entitlements
+
+Entitlements define **what features** users unlock when they purchase. Think of them as feature flags tied to purchases.
+
+**Tool:** \`capivv_create_entitlement\`
+**Example:**
+- identifier: "pro"
+- display_name: "Pro Access"
+- description: "Unlocks all premium features"
+
+Most apps need just one entitlement (e.g., "pro" or "premium"). Create more if you have tiered access.
+
+**Save the returned \`id\`** — you'll link it to products next.
+
+---
+
+## Step 3: Create Products
+
+Products are the actual purchasable items (subscriptions, one-time purchases). They map 1:1 to your App Store / Google Play products.
+
+**Tool:** \`capivv_create_product\`
+**Example (monthly subscription):**
+- app_id: (from Step 1)
+- external_id: "com.yourcompany.yourapp.monthly" (must match your store product ID)
+- product_type: "subscription"
+- display_name: "Monthly Plan"
+- entitlement_ids: [(entitlement ID from Step 2)]
+- subscription: { billing_period: "month" }
+- prices: [{ currency: "USD", amount_cents: 799, is_default: true }]
+
+**Example (annual subscription):**
+- app_id: (from Step 1)
+- external_id: "com.yourcompany.yourapp.yearly"
+- product_type: "subscription"
+- display_name: "Annual Plan"
+- entitlement_ids: [(entitlement ID from Step 2)]
+- subscription: { billing_period: "year" }
+- prices: [{ currency: "USD", amount_cents: 4999, is_default: true }]
+
+**Important:** The \`external_id\` must exactly match the product ID in App Store Connect / Google Play Console.
+
+---
+
+## Step 4: Create an Offering
+
+An offering bundles your products into a group that your paywall displays. This is what your SDK fetches to show purchase options.
+
+**Tool:** \`capivv_create_offering\`
+**Example:**
+- app_id: (from Step 1)
+- identifier: "default" (or a custom name like "pro_plans")
+- display_name: "Pro Plans"
+- is_default: true
+- packages:
+  - { identifier: "monthly", product_id: (monthly product ID), display_name: "Monthly", package_type: "monthly", position: 0 }
+  - { identifier: "annual", product_id: (annual product ID), display_name: "Annual", package_type: "annual", position: 1 }
+
+---
+
+## Step 5: Integrate the SDK
+
+With your Capivv backend configured, integrate the SDK into your app:
+
+### Get Your API Key
+Go to the **Capivv dashboard → Settings → Developer → API Keys** and copy your **public key** (starts with \`capivv_pk_\`).
+
+### iOS (Swift)
+\`\`\`swift
+import Capivv
+
+// In your App init or AppDelegate
+Capivv.configure(apiKey: "capivv_pk_...")
+
+// Identify the user
+Capivv.shared.login(userId: "user_123")
+
+// Check entitlements
+let hasAccess = try await Capivv.shared.checkEntitlement("pro")
+
+// Fetch offerings for your paywall
+let offerings = try await Capivv.shared.getOfferings()
+\`\`\`
+
+### Web (JavaScript/TypeScript)
+\`\`\`typescript
+import { Capivv } from '@capivv/web-sdk';
+
+const capivv = new Capivv({ apiKey: 'capivv_pk_...' });
+await capivv.login('user_123');
+
+const hasAccess = await capivv.checkEntitlement('pro');
+const offerings = await capivv.getOfferings();
+\`\`\`
+
+---
+
+## Verify Your Setup
+
+Run \`capivv_status\` to confirm everything is configured. You should see:
+- 1+ apps
+- 1+ entitlements
+- 1+ products
+- 1+ offerings
+
+Or use \`capivv_verify_setup\` for a detailed checklist of what's ready and what's missing.
+
+---
+
+## What About Pricing in Other Countries?
+
+You do **not** hardcode international prices. Here's how it works:
+1. Set your **base USD price** when creating products in App Store Connect / Google Play Console
+2. Apple and Google automatically calculate equivalent prices for other regions (you can override per-country in each console)
+3. The Capivv SDK returns **localized price strings** from the store — your paywall shows those, not your env file values
+
+The prices in Capivv are for **analytics and reference only**. The store is the source of truth for what users actually pay.
+
+---
+
+## Common Patterns
+
+### Trial Offer
+Use \`capivv_apply_rule\` to create a rule that grants a free trial:
+- condition: \`never_subscribed\`
+- action: offer a discounted or free introductory period
+
+### Multiple Tiers (Free / Pro / Business)
+Create separate entitlements for each tier, then create products that grant the appropriate entitlement.
+
+### Churn Recovery
+Use rules with the \`churned_subscriber\` condition to show special rescue offers to users who cancelled.
+
+---
+
+## Need Help?
+
+- **Check setup status:** \`capivv_status\` or \`capivv_next_step\`
+- **Verify everything works:** \`capivv_verify_setup\`
+- **Browse concepts:** Read the \`capivv://docs/concepts\` resource
+- **Platform guides:** Read \`capivv://docs/guides/ios\`, \`capivv://docs/guides/android\`, or \`capivv://docs/guides/web\`
+`;
+export function registerQuickstartResource(server) {
+    server.resource('quickstart', 'capivv://docs/quickstart', { mimeType: 'text/markdown' }, async (uri) => {
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: QUICKSTART_GUIDE,
+                },
+            ],
+        };
+    });
+}

package/dist/resources/rules.js

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

package/dist/tools/activate-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 registerActivateRuleTool(server: McpServer, client: CapivvClient): void;

package/dist/tools/activate-rule.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export function registerActivateRuleTool(server, client) {
+    server.tool('capivv_activate_rule', 'Activate a business rule so it starts being evaluated for users.', {
+        rule_id: z.string().describe('Rule ID to activate'),
+    }, async ({ rule_id }) => {
+        const rule = await client.activateRule(rule_id);
+        return { content: [{ type: 'text', text: JSON.stringify(rule, null, 2) }] };
+    });
+}