@capivv/mcp-server 0.1.3 → 0.5.0

package/dist/tools/setup-wizard.js

@@ -0,0 +1,259 @@
+import { z } from 'zod';
+/**
+ * Only the messages we're confident indicate a conflict (existing row) should
+ * trigger the "list and reuse" fallback. Anything else — timeouts, 5xx,
+ * validation errors — is a legitimate failure that the caller needs to see.
+ */
+function isConflictError(msg) {
+    const lower = msg.toLowerCase();
+    return (lower.includes('already exists') ||
+        lower.includes('duplicate') ||
+        lower.includes('409') ||
+        lower.includes('conflict'));
+}
+export function registerSetupWizardTool(server, client) {
+    server.tool('capivv_setup_wizard', `One-shot setup for an EXISTING app: creates an entitlement, products, and offering on an app you've already imported via the Capivv dashboard's store-connect flow.
+
+As of V6 this tool does NOT create apps from scratch — connect your store in the dashboard to import apps with real bundle IDs. Use capivv_list_apps or capivv_whoami to see which apps are available.
+
+Example:
+  bundle_id: "com.mycompany.myapp"   // must already exist; omit if your tenant has exactly one app
+  entitlement_id: "pro"
+  products: [
+    { name: "Monthly", external_id: "com.mycompany.myapp.monthly", billing_period: "month", price_cents: 799 },
+    { name: "Annual", external_id: "com.mycompany.myapp.yearly", billing_period: "year", price_cents: 4999 }
+  ]
+  offering_id: "default"`, {
+        bundle_id: z
+            .string()
+            .optional()
+            .describe('Bundle ID of the existing app to configure. If omitted and the tenant has exactly one app, that app is used.'),
+        entitlement_id: z.string().describe('Entitlement identifier (e.g., "pro", "premium")'),
+        entitlement_name: z
+            .string()
+            .optional()
+            .describe('Entitlement display name (defaults to capitalized identifier)'),
+        products: z
+            .array(z.object({
+            name: z.string().describe('Product display name (e.g., "Monthly Plan")'),
+            external_id: z
+                .string()
+                .describe('Store product ID. With a connected store integration, Capivv creates this product in App Store Connect / Google Play too — pass the ID you want it to have there.'),
+            billing_period: z
+                .string()
+                .describe('Billing period: week, month, three_months, six_months, or year'),
+            price_cents: z.number().describe('Price in USD cents (e.g., 799 for $7.99)'),
+        }))
+            .describe('Subscription products to create'),
+        offering_id: z.string().optional().describe('Offering identifier (default: "default")'),
+        offering_name: z
+            .string()
+            .optional()
+            .describe('Offering display name (default: based on entitlement)'),
+    }, async (args) => {
+        // Step 0: resolve identity + reachable apps. Every wizard response
+        // carries `tenant` so the caller can see which workspace is being
+        // written to — if this org_name doesn't match expectations, stop.
+        const me = await client.whoami();
+        const result = {
+            success: true,
+            tenant: { tenant_id: me.tenant_id, org_name: me.org_name },
+            resolved_app: null,
+            created: { entitlements: [], products: [] },
+            skipped_existing: [],
+            errors: [],
+            next_steps: [],
+        };
+        // Step 1: resolve which app to configure. No more hardcoded placeholder
+        // app creation — the app must already exist via dashboard import.
+        let selected = null;
+        if (me.apps.length === 0) {
+            result.success = false;
+            result.errors.push(`Workspace "${me.org_name}" has no apps yet. Connect your store in the dashboard (Settings → Developer → Integrations) and import at least one app first, then re-run this wizard.`);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        if (args.bundle_id) {
+            const match = me.apps.find((a) => a.bundle_id === args.bundle_id);
+            if (!match) {
+                result.success = false;
+                result.errors.push(`No app with bundle_id "${args.bundle_id}" in workspace "${me.org_name}". Available: ${me.apps.map((a) => a.bundle_id).join(', ')}.`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            // whoami returns a subset of App fields — fetch the full row so we
+            // can use it as the appId source.
+            const apps = await client.listApps();
+            selected = apps.find((a) => a.id === match.id) ?? null;
+        }
+        else if (me.apps.length === 1) {
+            const apps = await client.listApps();
+            selected = apps.find((a) => a.id === me.apps[0].id) ?? null;
+        }
+        else {
+            result.success = false;
+            result.errors.push(`Workspace "${me.org_name}" has ${me.apps.length} apps — pass bundle_id to pick one. Options: ${me.apps.map((a) => `${a.bundle_id} (${a.name})`).join(', ')}.`);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        if (!selected) {
+            result.success = false;
+            result.errors.push('Failed to resolve app from the tenant');
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        result.resolved_app = {
+            id: selected.id,
+            name: selected.name,
+            bundle_id: selected.bundle_id ?? '',
+            platform: selected.platform,
+        };
+        const appId = selected.id;
+        // Step 2: Create entitlement. Conflict (already exists) is treated as a
+        // skip, not a failure; everything else aborts loud.
+        let entitlementId;
+        try {
+            const entitlement = await client.createEntitlement({
+                identifier: args.entitlement_id,
+                display_name: args.entitlement_name ??
+                    args.entitlement_id.charAt(0).toUpperCase() + args.entitlement_id.slice(1),
+            });
+            result.created.entitlements.push(entitlement);
+            entitlementId = entitlement.id;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (isConflictError(msg)) {
+                const entitlements = await client.listEntitlements();
+                const existing = entitlements.find((e) => e.identifier === args.entitlement_id);
+                if (existing) {
+                    entitlementId = existing.id;
+                    result.skipped_existing.push(`entitlement:${args.entitlement_id}`);
+                }
+                else {
+                    result.success = false;
+                    result.errors.push(`Entitlement "${args.entitlement_id}" reported as existing but couldn't be found — aborting`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+            }
+            else {
+                result.success = false;
+                result.errors.push(`Entitlement creation failed: ${msg}`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+        }
+        // Step 3: Create products
+        const PERIOD_TO_PACKAGE = {
+            week: 'weekly',
+            month: 'monthly',
+            three_months: 'three_month',
+            six_months: 'six_month',
+            year: 'annual',
+        };
+        for (const p of args.products) {
+            try {
+                const product = await client.createProduct({
+                    app_id: appId,
+                    external_id: p.external_id,
+                    product_type: 'subscription',
+                    display_name: p.name,
+                    entitlement_ids: entitlementId ? [entitlementId] : [],
+                    subscription: { billing_period: p.billing_period },
+                    prices: [{ currency: 'USD', amount_cents: p.price_cents, is_default: true }],
+                });
+                result.created.products.push(product);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (isConflictError(msg)) {
+                    const products = await client.listProducts(appId);
+                    const existing = products.find((pr) => pr.external_id === p.external_id);
+                    if (existing) {
+                        result.created.products.push(existing);
+                        result.skipped_existing.push(`product:${p.external_id}`);
+                    }
+                    else {
+                        result.success = false;
+                        result.errors.push(`Product "${p.name}" reported as existing but couldn't be found — aborting`);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                }
+                else {
+                    result.success = false;
+                    result.errors.push(`Product "${p.name}" creation failed: ${msg}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+            }
+        }
+        // Step 4: Create offering
+        if (result.created.products.length > 0) {
+            const offeringId = args.offering_id ?? 'default';
+            const offeringName = args.offering_name ??
+                `${args.entitlement_id.charAt(0).toUpperCase() + args.entitlement_id.slice(1)} Plans`;
+            const packages = result.created.products.map((product, index) => {
+                const inputProduct = args.products.find((p) => p.external_id === product.external_id);
+                const packageType = inputProduct
+                    ? (PERIOD_TO_PACKAGE[inputProduct.billing_period] ?? 'custom')
+                    : 'custom';
+                return {
+                    identifier: packageType,
+                    product_id: product.id,
+                    display_name: product.display_name,
+                    package_type: packageType,
+                    position: index,
+                };
+            });
+            try {
+                result.created.offering = await client.createOffering({
+                    app_id: appId,
+                    identifier: offeringId,
+                    display_name: offeringName,
+                    is_default: true,
+                    packages,
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (isConflictError(msg)) {
+                    const offerings = await client.listOfferings();
+                    const existing = offerings.find((o) => o.identifier === offeringId);
+                    if (existing) {
+                        result.created.offering = existing;
+                        result.skipped_existing.push(`offering:${offeringId}`);
+                    }
+                    else {
+                        result.success = false;
+                        result.errors.push(`Offering "${offeringId}" reported as existing but couldn't be found — aborting`);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                }
+                else {
+                    result.success = false;
+                    result.errors.push(`Offering creation failed: ${msg}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+            }
+        }
+        // Build next steps
+        result.next_steps.push(`Wrote to workspace "${result.tenant.org_name}" (tenant_id: ${result.tenant.tenant_id}, app: ${result.resolved_app.bundle_id}). If that's the wrong workspace, switch your CAPIVV_API_KEY env var before continuing.`);
+        result.next_steps.push('Integrate the SDK: copy the publishable (pk_*) key generated for this app from Settings → Developer → API Keys. Read capivv://docs/quickstart for code examples.');
+        result.next_steps.push('Verify: Run capivv_verify_setup to check that everything is configured correctly.');
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+}

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

package/dist/tools/start-experiment.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export function registerStartExperimentTool(server, client) {
+    server.tool('capivv_start_experiment', 'Flip an experiment from draft to running. New users now get assigned to variants based on traffic_percent. Use capivv_get_experiment_summary to monitor progress.', {
+        experiment_id: z.string().describe('Experiment ID to start'),
+    }, async ({ experiment_id }) => {
+        const exp = await client.startExperiment(experiment_id);
+        return { content: [{ type: 'text', text: JSON.stringify(exp, null, 2) }] };
+    });
+}

package/dist/tools/status.js

@@ -1,3 +1,4 @@
+import { ApiError } from '../client.js';
 const STEP_GUIDANCE = {
     app_created: 'Create your first app with capivv_list_apps to see current apps, or create one in the Capivv dashboard.',
     entitlement_created: 'Define entitlements to control feature access. Entitlements are granted when users purchase products.',
@@ -11,7 +12,7 @@ const STEP_GUIDANCE = {
 };
 export function registerStatusTool(server, client) {
     server.tool('capivv_status', 'Get the current status of your Capivv subscription platform including setup progress, resource counts, and key metrics.', async () => {
-        const [apps, products, entitlements, offerings, rules, onboarding, analytics] = await Promise.allSettled([
+        const settled = await Promise.allSettled([
             client.listApps(),
             client.listProducts(),
             client.listEntitlements(),
@@ -20,6 +21,26 @@ export function registerStatusTool(server, client) {
             client.getOnboarding(),
             client.getAnalyticsOverview(),
         ]);
+        const [apps, products, entitlements, offerings, rules, onboarding, analytics] = settled;
+        // Every call goes through the same Bearer-token auth. If even one returns
+        // 401, the bearer is bad and every count we'd report would be a lie —
+        // short-circuit with a clear message instead of rendering zeros.
+        const authFailure = settled.find((r) => r.status === 'rejected' && r.reason instanceof ApiError && r.reason.status === 401);
+        if (authFailure) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Authentication failed (HTTP 401). Verify CAPIVV_API_KEY (or the Bearer token your MCP client is sending) is a valid sk_* secret key.',
+                    },
+                ],
+            };
+        }
+        const labels = ['apps', 'products', 'entitlements', 'offerings', 'rules', 'onboarding', 'analytics'];
+        const warnings = settled
+            .map((r, i) => (r.status === 'rejected' ? `${labels[i]}: ${r.reason.message}` : null))
+            .filter((w) => w !== null);
         const count = (r) => r.status === 'fulfilled' ? r.value.length : 0;
         const result = {
             resources: {
@@ -30,6 +51,9 @@ export function registerStatusTool(server, client) {
                 rules: count(rules),
             },
         };
+        if (warnings.length) {
+            result._warnings = warnings;
+        }
         if (onboarding.status === 'fulfilled') {
             const ob = onboarding.value;
             result.onboarding = {

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

package/dist/tools/stop-experiment.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export function registerStopExperimentTool(server, client) {
+    server.tool('capivv_stop_experiment', 'Mark an experiment as completed. New users stop being assigned to variants; existing assignments are preserved for analysis. Use capivv_get_experiment_summary to read final results.', {
+        experiment_id: z.string().describe('Experiment ID to stop'),
+    }, async ({ experiment_id }) => {
+        const exp = await client.stopExperiment(experiment_id);
+        return { content: [{ type: 'text', text: JSON.stringify(exp, null, 2) }] };
+    });
+}

package/dist/tools/sync-suggestions-count.d.ts

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

package/dist/tools/sync-suggestions-count.js

@@ -0,0 +1,6 @@
+export function registerSyncSuggestionsCountTool(server, client) {
+    server.tool('capivv_sync_suggestions_count', 'Get the count of pending drift suggestions across the workspace. A quick health check before deciding whether to call capivv_check_drift for full details.', async () => {
+        const count = await client.getSyncSuggestionsCount();
+        return { content: [{ type: 'text', text: JSON.stringify(count, null, 2) }] };
+    });
+}

package/dist/tools/trigger-sync.d.ts

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

package/dist/tools/trigger-sync.js

@@ -0,0 +1,6 @@
+export function registerTriggerSyncTool(server, client) {
+    server.tool('capivv_trigger_sync', 'Force an immediate sync run for every connected store integration in the workspace. Useful right after creating products in App Store Connect or Google Play to surface them as drift suggestions without waiting for the worker\'s scheduled interval.', async () => {
+        const result = await client.triggerSync();
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+}

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

package/dist/tools/update-app.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export function registerUpdateAppTool(server, client) {
+    server.tool('capivv_update_app', 'Update an app by ID. Provide only the fields you want to change. Common uses: rename, fix a placeholder bundle_id, edit settings.', {
+        app_id: z.string().describe('App ID'),
+        name: z.string().optional().describe('New display name'),
+        bundle_id: z
+            .string()
+            .optional()
+            .describe('New bundle ID (use to fix a placeholder like com.example.myapp)'),
+        settings: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Free-form settings JSON (merged into existing)'),
+    }, async (args) => {
+        const { app_id, ...rest } = args;
+        const app = await client.updateApp(app_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(app, null, 2) }] };
+    });
+}

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

package/dist/tools/update-entitlement.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export function registerUpdateEntitlementTool(server, client) {
+    server.tool('capivv_update_entitlement', 'Update an entitlement by ID. Provide only the fields you want to change.', {
+        entitlement_id: z.string().describe('Entitlement ID'),
+        identifier: z.string().optional().describe('New stable identifier'),
+        display_name: z.string().optional().describe('New display name'),
+        description: z.string().optional().describe('New description'),
+    }, async (args) => {
+        const { entitlement_id, ...rest } = args;
+        const ent = await client.updateEntitlement(entitlement_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(ent, null, 2) }] };
+    });
+}

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

package/dist/tools/update-experiment.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export function registerUpdateExperimentTool(server, client) {
+    server.tool('capivv_update_experiment', 'Update an experiment by ID. Provide only the fields you want to change. Use capivv_start_experiment / capivv_stop_experiment for status flips so audit logs and assignment freezing fire correctly.', {
+        experiment_id: z.string().describe('Experiment ID to update'),
+        name: z.string().optional().describe('New display name'),
+        description: z.string().optional().describe('New description'),
+        status: z
+            .string()
+            .optional()
+            .describe('New status (draft / running / paused / completed). Prefer start/stop tools.'),
+        target_metric: z.string().optional().describe('New target metric'),
+        start_date: z.string().optional().describe('New start timestamp (ISO 8601)'),
+        end_date: z.string().optional().describe('New end timestamp (ISO 8601)'),
+        sample_size_target: z.number().optional().describe('New sample size target'),
+        confidence_level: z.number().optional().describe('New confidence level'),
+        metadata: z.record(z.string(), z.unknown()).optional().describe('Free-form metadata'),
+    }, async (args) => {
+        const { experiment_id, ...rest } = args;
+        const exp = await client.updateExperiment(experiment_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(exp, null, 2) }] };
+    });
+}

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

package/dist/tools/update-offering.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export function registerUpdateOfferingTool(server, client) {
+    server.tool('capivv_update_offering', 'Update an offering by ID. Provide only the fields you want to change. Pass `packages` to replace the package list (full replacement, not merge — include every package you want to keep).', {
+        offering_id: z.string().describe('Offering ID'),
+        display_name: z.string().optional().describe('New display name'),
+        description: z.string().optional().describe('New description'),
+        is_default: z
+            .boolean()
+            .optional()
+            .describe('Whether this is the default offering for its app'),
+        packages: z
+            .array(z.object({
+            identifier: z.string(),
+            product_id: z.string(),
+            display_name: z.string(),
+            description: z.string().optional(),
+            package_type: z.string().describe('monthly | annual | weekly | lifetime | custom'),
+            position: z.number(),
+        }))
+            .optional()
+            .describe('Replacement package list (full replacement, not merge)'),
+        metadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Free-form metadata (replaces existing)'),
+    }, async (args) => {
+        const { offering_id, ...rest } = args;
+        const offering = await client.updateOffering(offering_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(offering, null, 2) }] };
+    });
+}

package/dist/tools/update-paywall.d.ts

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

package/dist/tools/update-paywall.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export function registerUpdatePaywallTool(server, client) {
+    server.tool('capivv_update_paywall', 'Update a paywall by ID. Provide only the fields you want to change. Use this to attach a template, swap the config blob, or update metadata. Use capivv_list_paywalls to discover the paywall_id.', {
+        paywall_id: z.string().describe('Paywall ID to update'),
+        name: z.string().optional().describe('New display name'),
+        template: z
+            .string()
+            .optional()
+            .describe('Template identifier (e.g. "default", "minimal", "image_first")'),
+        config: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Paywall configuration JSON (layout, copy, products to display, etc.)'),
+        metadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Free-form metadata stored alongside the paywall'),
+    }, async (args) => {
+        const { paywall_id, ...rest } = args;
+        const paywall = await client.updatePaywall(paywall_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(paywall, null, 2) }] };
+    });
+}

package/dist/tools/update-product.d.ts

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

package/dist/tools/update-product.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export function registerUpdateProductTool(server, client) {
+    server.tool('capivv_update_product', 'Update an existing product. Only provided fields are changed.', {
+        product_id: z.string().describe('Product ID to update'),
+        external_id: z.string().optional().describe('New store product ID'),
+        display_name: z.string().optional().describe('New display name'),
+        description: z.string().optional().describe('New description'),
+        entitlement_ids: z
+            .array(z.string())
+            .optional()
+            .describe('New entitlement IDs (replaces existing)'),
+    }, async ({ product_id, ...updates }) => {
+        const product = await client.updateProduct(product_id, updates);
+        return { content: [{ type: 'text', text: JSON.stringify(product, null, 2) }] };
+    });
+}

package/dist/tools/update-promotion.d.ts

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

package/dist/tools/update-promotion.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export function registerUpdatePromotionTool(server, client) {
+    server.tool('capivv_update_promotion', 'Update a promotion by ID. Provide only the fields you want to change. Use capivv_list_promotions to discover the promotion_id.', {
+        promotion_id: z.string().describe('Promotion ID to update'),
+        name: z.string().optional().describe('New display name'),
+        description: z.string().optional().describe('New description'),
+        discount_percent: z
+            .number()
+            .optional()
+            .describe('New percentage discount (0-100)'),
+        max_redemptions: z
+            .number()
+            .optional()
+            .describe('New redemption cap. Reduce only — increasing past current_redemptions is a no-op.'),
+    }, async (args) => {
+        const { promotion_id, ...rest } = args;
+        const promotion = await client.updatePromotion(promotion_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(promotion, null, 2) }] };
+    });
+}

package/dist/tools/update-rescue-flow.d.ts

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

package/dist/tools/update-rescue-flow.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export function registerUpdateRescueFlowTool(server, client) {
+    server.tool('capivv_update_rescue_flow', [
+        'Update a rescue flow by ID. Provide only the fields you want to change.',
+        '`conditions` is an eligibility filter object (e.g. { product_ids: [...], min_tenure_days: 30 }).',
+        '`steps` is the offer ladder shown to the user during cancellation (e.g. [{ type: "discount", percent: 50 }, { type: "pause", months: 1 }]).',
+        'Use capivv_list_rescue_flows to discover the rescue_flow_id.',
+    ].join(' '), {
+        rescue_flow_id: z.string().describe('Rescue flow ID to update'),
+        name: z.string().optional().describe('New display name'),
+        description: z.string().optional().describe('New description'),
+        priority: z.number().optional().describe('New priority'),
+        conditions: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Eligibility filter object'),
+        steps: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('Offer ladder configuration'),
+        metadata: z.record(z.string(), z.unknown()).optional().describe('Free-form metadata'),
+    }, async (args) => {
+        const { rescue_flow_id, ...rest } = args;
+        const flow = await client.updateRescueFlow(rescue_flow_id, rest);
+        return { content: [{ type: 'text', text: JSON.stringify(flow, null, 2) }] };
+    });
+}

package/dist/tools/verify-setup.d.ts

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