@capivv/mcp-server 0.1.3 → 0.5.0

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) }] };
+    });
+}

package/dist/tools/api-key-usage.d.ts

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

package/dist/tools/api-key-usage.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+// V7 Phase C.5 — AI-callable SDK usage telemetry.
+//
+// Same backend endpoint the dashboard Usage dialog uses
+// (/dashboard/settings/api-keys/:id/usage). The MCP surface exists because
+// "is this key compromised?" is a question AI assistants are often asked —
+// they can fetch the data, render it inline, and compare against the
+// anomaly-detection rules documented in the runbook without the user
+// context-switching to the dashboard.
+export function registerApiKeyUsageTool(server, client) {
+    server.tool('capivv_api_key_usage', `Fetch request-level telemetry for a specific publishable API key (pk_live_* / pk_test_*). Returns hourly buckets of request counts, error counts, distinct IPs, SDK versions, and country codes — the same data the dashboard's Usage tab renders. Use this to investigate a suspected key leak: look for sudden IP spread, unexpected country codes, or rate spikes vs. a prior baseline.`, {
+        api_key_id: z
+            .string()
+            .describe('The api_keys.id of the key to inspect (UUID). Use capivv_whoami to see available apps — key IDs appear under each app in the dashboard Settings → Developer page.'),
+        hours: z
+            .number()
+            .int()
+            .min(1)
+            .max(168)
+            .optional()
+            .describe('Window in hours to summarize over (default 24, max 168 = 7 days).'),
+    }, async ({ api_key_id, hours }) => {
+        const usage = await client.getApiKeyUsage(api_key_id, hours ?? 24);
+        const lines = [];
+        lines.push(`Usage for key ${api_key_id.slice(0, 8)}… over the last ${usage.hours} hour(s):`);
+        lines.push('');
+        lines.push(`  Requests:        ${usage.summary.total_requests.toLocaleString()}`);
+        lines.push(`  Errors:          ${usage.summary.total_errors.toLocaleString()}`);
+        lines.push(`  Unique IPs:      ${usage.summary.distinct_ips}`);
+        lines.push(`  Countries:       ${usage.summary.distinct_countries}`);
+        lines.push(`  SDK versions:    ${usage.summary.distinct_sdk_versions}`);
+        lines.push('');
+        // Anomaly signals inline — surface the same ones the hourly scanner
+        // checks in capivv-workers::api_key_anomaly. AI assistant can quote
+        // these directly when answering "is this key compromised?"
+        const signals = [];
+        if (usage.summary.distinct_ips >= 5) {
+            signals.push(`  • ${usage.summary.distinct_ips} distinct IPs is high for a single app — investigate if this is expected.`);
+        }
+        if (usage.summary.distinct_countries >= 3) {
+            signals.push(`  • Traffic from ${usage.summary.distinct_countries} countries. If your app isn't multi-region, consider revoking.`);
+        }
+        if (usage.summary.total_requests > 10_000 && usage.hours <= 24) {
+            signals.push(`  • ${usage.summary.total_requests.toLocaleString()} requests in ${usage.hours}h crosses the 10k/hour absolute-volume threshold.`);
+        }
+        if (signals.length > 0) {
+            lines.push('Anomaly signals:');
+            lines.push(...signals);
+            lines.push('');
+        }
+        if (usage.samples.length === 0) {
+            lines.push('No traffic recorded in the selected window.');
+        }
+        else {
+            lines.push(`Sample buckets (showing up to 10 of ${usage.samples.length}):`);
+            for (const s of usage.samples.slice(0, 10)) {
+                const ip = s.client_ip ?? 'unknown';
+                const sdk = s.sdk_version ?? 'unknown';
+                const country = s.country_code ?? '??';
+                lines.push(`  ${s.bucket_start}  ${s.request_count}req/${s.error_count}err  ${ip}  ${sdk}  ${country}`);
+            }
+        }
+        return {
+            content: [
+                { type: 'text', text: lines.join('\n') },
+                { type: 'text', text: JSON.stringify(usage, null, 2) },
+            ],
+        };
+    });
+}

package/dist/tools/apply-rule.js

@@ -1,33 +1,74 @@
 import { z } from 'zod';
+import YAML from 'yaml';
 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'),
+    server.tool('capivv_apply_rule', `Apply a YAML rule configuration. Validates the rule first, then creates or updates it.
+
+Example YAML:
+  conditions:
+    - type: never_subscribed
+  actions:
+    - type: grant_entitlement
+      identifier: "trial_access"
+      expires_in_days: 7
+      reason: "New user trial"
+
+Condition types: audience, attribute, date_range, percentage, has_entitlement, has_product, subscription_status, renewal_window, is_trial_period, never_subscribed, churned_subscriber, country, platform, app_version
+Action types: override_price, discount_percent, discount_fixed, grant_entitlement, set_paywall, show_offering, cancel_offer, track_event, set_attribute`, {
+        name: z.string().describe('Rule name (used as both identifier and display name)'),
+        content: z.string().describe('YAML rule content with conditions and actions arrays'),
         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 }) => {
+        // Parse YAML to extract conditions, actions, guardrails
+        let parsed;
+        try {
+            parsed = YAML.parse(content);
+            if (!parsed || typeof parsed !== 'object') {
+                throw new Error('YAML must be an object with conditions and/or actions');
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: false,
+                            error: `Invalid YAML: ${e instanceof Error ? e.message : String(e)}`,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        const conditions = parsed.conditions ?? [];
+        const actions = parsed.actions ?? [];
+        const guardrails = parsed.guardrails;
         // Validate first
-        const validation = await client.validateRule(content);
+        const validation = await client.validateRule({ conditions, actions, guardrails });
         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) }],
+                content: [{ type: 'text', text: JSON.stringify({
+                            success: false,
+                            validation_errors: validation.errors,
+                            validation_warnings: validation.warnings,
+                        }, null, 2) }],
                 isError: true,
             };
         }
-        // Create/update the rule
-        const rule = await client.upsertRule({ name, content, priority, is_enabled });
+        // Create the rule
+        const identifier = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+        const rule = await client.createRule({
+            identifier,
+            name,
+            conditions,
+            actions,
+            guardrails,
+            priority,
+        });
         const result = {
             success: true,
             rule: {
                 id: rule.id,
+                identifier: rule.identifier,
                 name: rule.name,
                 priority: rule.priority,
-                is_enabled: rule.is_enabled,
+                status: rule.status,
                 updated_at: rule.updated_at,
             },
             validation_warnings: validation.warnings.length > 0 ? validation.warnings : undefined,

package/dist/tools/approve-change-request.d.ts

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

package/dist/tools/approve-change-request.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export function registerApproveChangeRequestTool(server, client) {
+    server.tool('capivv_approve_change_request', 'Approve a pending pricing change request. The new price is applied to Capivv immediately. Use capivv_push_prices_to_stores afterwards to propagate to App Store Connect / Google Play.', {
+        change_request_id: z.string().describe('Change request ID to approve'),
+    }, async ({ change_request_id }) => {
+        await client.approvePricingChangeRequest(change_request_id);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Change request ${change_request_id} approved. The new price is now in Capivv. Call capivv_push_prices_to_stores to propagate to the stores.`,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/archive-app.d.ts

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

package/dist/tools/archive-app.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export function registerArchiveAppTool(server, client) {
+    server.tool('capivv_archive_app', 'Archive an app (soft delete). The app stops serving new traffic but its data is preserved. Use capivv_restore_app to bring it back. Prefer this over capivv_delete_app unless permanent removal is required.', {
+        app_id: z.string().describe('App ID to archive'),
+    }, async ({ app_id }) => {
+        const app = await client.archiveApp(app_id);
+        return { content: [{ type: 'text', text: JSON.stringify(app, null, 2) }] };
+    });
+}

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

package/dist/tools/autopilot-status.js

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+// V7 B.5 — capivv_autopilot_status
+//
+// Answers "show me everything autopilot did for this app" from one MCP call.
+// Composed from the existing listOfferings / listRules / listExperiments
+// client methods plus the listApps lookup to resolve the app name — no new
+// backend endpoint. Paywalls + rescue flows + promotions live in the same
+// autopilot provenance story but don't have MCP list methods today; the tool
+// surfaces a link to the dashboard pages where those badges also render.
+export function registerAutopilotStatusTool(server, client) {
+    server.tool('capivv_autopilot_status', `Show everything autopilot generated for a specific app — offerings, entitlement rules, and experiments, filtered by the generated_by provenance marker. Useful right after capivv_setup_wizard or import-apps to confirm what was auto-created, or when a user asks "what did autopilot do for app X?"`, {
+        app_id: z
+            .string()
+            .describe('The Capivv app ID to inspect. Use capivv_list_apps to find it, or capivv_whoami to see all apps reachable from your API key.'),
+    }, async ({ app_id }) => {
+        const [apps, offerings, rules, experiments] = await Promise.all([
+            client.listApps(),
+            client.listOfferings(),
+            client.listRules(),
+            client.listExperiments(),
+        ]);
+        const app = apps.find((a) => a.id === app_id);
+        if (!app) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No app found with id ${app_id}. Available apps: ${apps.map((a) => `${a.name} (${a.id})`).join(', ') || 'none'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // generated_by uses an `autopilot_v` prefix across versions. Matching
+        // on the prefix lets the tool show v1 + v2 resources without hard-
+        // coding version strings that'll drift.
+        const autopilotStamp = (gb) => typeof gb === 'string' && gb.startsWith('autopilot_');
+        const autopilotOfferings = offerings.filter((o) => o.app_id === app_id && autopilotStamp(o.generated_by));
+        const autopilotRules = rules.filter((r) => {
+            if (!autopilotStamp(r.generated_by))
+                return false;
+            // Rules are tenant-scoped; we tagged the source app_id in metadata.
+            const md = r.metadata;
+            return md?.generated_for_app_id === app_id;
+        });
+        const autopilotExperiments = experiments.filter((e) => {
+            if (!autopilotStamp(e.generated_by))
+                return false;
+            const md = e.metadata;
+            return md?.generated_for_app_id === app_id;
+        });
+        const totals = {
+            offerings: autopilotOfferings.length,
+            rules: autopilotRules.length,
+            experiments: autopilotExperiments.length,
+        };
+        const nothing = totals.offerings + totals.rules + totals.experiments === 0;
+        const lines = [];
+        lines.push(`Autopilot status for ${app.name} (${app.bundle_id ?? app_id})`);
+        lines.push('');
+        if (nothing) {
+            lines.push("No autopilot-generated resources for this app (yet). If you just ran capivv_setup_wizard or imported products, try again — autopilot runs inline during import.");
+        }
+        else {
+            lines.push(`Summary: ${totals.offerings} offering, ${totals.rules} rule(s), ${totals.experiments} experiment(s).`);
+            lines.push('');
+            if (autopilotOfferings.length > 0) {
+                lines.push('Offerings:');
+                for (const o of autopilotOfferings) {
+                    lines.push(`  • ${o.identifier} — ${o.display_name} [${o.generated_by}]`);
+                }
+            }
+            if (autopilotRules.length > 0) {
+                lines.push('Rules:');
+                for (const r of autopilotRules) {
+                    lines.push(`  • ${r.identifier} — ${r.name} [${r.generated_by}]`);
+                }
+            }
+            if (autopilotExperiments.length > 0) {
+                lines.push('Experiments:');
+                for (const e of autopilotExperiments) {
+                    lines.push(`  • ${e.name} — status: ${e.status} [${e.generated_by}]`);
+                }
+            }
+            lines.push('');
+            lines.push('Paywalls + rescue flows + promotions also carry the "Autopilot" badge — open /paywalls, /rescue, /promotions in the dashboard to see them there.');
+        }
+        return {
+            content: [
+                { type: 'text', text: lines.join('\n') },
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        app: { id: app_id, name: app.name, bundle_id: app.bundle_id },
+                        totals,
+                        offerings: autopilotOfferings.map((o) => ({
+                            id: o.id,
+                            identifier: o.identifier,
+                            generated_by: o.generated_by,
+                        })),
+                        rules: autopilotRules.map((r) => ({
+                            id: r.id,
+                            identifier: r.identifier,
+                            generated_by: r.generated_by,
+                        })),
+                        experiments: autopilotExperiments.map((e) => ({
+                            id: e.id,
+                            name: e.name,
+                            status: e.status,
+                            generated_by: e.generated_by,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/check-drift.d.ts

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

package/dist/tools/check-drift.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export function registerCheckDriftTool(server, client) {
+    server.tool('capivv_check_drift', [
+        'List drift between Capivv and the connected store(s) — products that exist in the store but not in Capivv, prices that differ, metadata that changed, products deleted from the store.',
+        'Each entry has a `suggestion_type` (new_product | price_changed | metadata_changed | product_deleted) and a `diff_details` payload describing the mismatch.',
+        'Use capivv_resolve_drift to accept (apply the change) or dismiss (ignore) each one.',
+        'Drift is detected continuously by the background sync worker; call capivv_trigger_sync to force an immediate scan if you suspect the listing is stale.',
+    ].join(' '), {
+        app_id: z
+            .string()
+            .optional()
+            .describe('Filter by app. When omitted, the API returns drift for the first app in the workspace.'),
+        status: z
+            .string()
+            .optional()
+            .describe('Filter by status: pending (default), accepted, dismissed, auto_resolved'),
+    }, async ({ app_id, status }) => {
+        const suggestions = await client.listSyncSuggestions(app_id, status);
+        return { content: [{ type: 'text', text: JSON.stringify(suggestions, null, 2) }] };
+    });
+}

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

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

package/dist/tools/create-app.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export function registerCreateAppTool(server, client) {
+    server.tool('capivv_create_app', 'Create a new app in Capivv with an explicit bundle ID. Prefer the dashboard\'s store-connect flow (which imports apps with real bundle IDs automatically); this tool is the manual fallback for web apps or apps without a store presence.', {
+        name: z.string().describe('App name (e.g., "My App")'),
+        platform: z.string().describe('Platform: ios, android, or web'),
+        bundle_id: z
+            .string()
+            .describe('Bundle identifier. Use your real reverse-DNS ID (e.g., "com.yourcompany.yourapp") — do NOT use com.example.myapp or other placeholder values.'),
+    }, async (args) => {
+        const app = await client.createApp(args);
+        return { content: [{ type: 'text', text: JSON.stringify(app, null, 2) }] };
+    });
+}

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

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

package/dist/tools/create-entitlement.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export function registerCreateEntitlementTool(server, client) {
+    server.tool('capivv_create_entitlement', 'Create a new entitlement (feature access identifier). Products grant entitlements to users upon purchase.', {
+        identifier: z.string().describe('Unique identifier (e.g., "premium", "pro_features")'),
+        display_name: z.string().describe('Human-readable name (e.g., "Premium Access")'),
+        description: z.string().optional().describe('Optional description of what this entitlement unlocks'),
+    }, async (args) => {
+        const entitlement = await client.createEntitlement(args);
+        return { content: [{ type: 'text', text: JSON.stringify(entitlement, null, 2) }] };
+    });
+}

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

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