@odavl/guardian 0.1.0-rc1 → 1.0.0

package/src/payments/stripe-checkout.js

@@ -0,0 +1,169 @@
+/**
+ * ODAVL Guardian Stripe Integration
+ * Real Stripe checkout for PRO and BUSINESS plans
+ */
+
+const { PLANS } = require('../plans/plan-definitions');
+const { setCurrentPlan } = require('../plans/plan-manager');
+
+// Stripe configuration
+const STRIPE_PUBLIC_KEY = process.env.STRIPE_PUBLIC_KEY || '';
+const STRIPE_SECRET_KEY = process.env.STRIPE_SECRET_KEY || '';
+const STRIPE_WEBHOOK_SECRET = process.env.STRIPE_WEBHOOK_SECRET || '';
+
+/**
+ * Create Stripe checkout session
+ * This is called from the website when user clicks "Upgrade"
+ */
+async function createCheckoutSession(planId, successUrl, cancelUrl) {
+  if (!STRIPE_SECRET_KEY) {
+    throw new Error('Stripe is not configured. Set STRIPE_SECRET_KEY environment variable.');
+  }
+  
+  const stripe = require('stripe')(STRIPE_SECRET_KEY);
+  const plan = PLANS[planId.toUpperCase()];
+  
+  if (!plan || !plan.stripePriceId) {
+    throw new Error(`Invalid plan: ${planId}`);
+  }
+  
+  const session = await stripe.checkout.sessions.create({
+    mode: 'subscription',
+    payment_method_types: ['card'],
+    line_items: [
+      {
+        price: plan.stripePriceId,
+        quantity: 1,
+      },
+    ],
+    success_url: successUrl,
+    cancel_url: cancelUrl,
+    metadata: {
+      planId: plan.id,
+    },
+  });
+  
+  return {
+    sessionId: session.id,
+    url: session.url,
+  };
+}
+
+/**
+ * Handle Stripe webhook events
+ * Called when payment succeeds or subscription changes
+ */
+async function handleWebhook(requestBody, signature) {
+  if (!STRIPE_SECRET_KEY || !STRIPE_WEBHOOK_SECRET) {
+    throw new Error('Stripe webhooks not configured');
+  }
+  
+  const stripe = require('stripe')(STRIPE_SECRET_KEY);
+  
+  let event;
+  try {
+    event = stripe.webhooks.constructEvent(
+      requestBody,
+      signature,
+      STRIPE_WEBHOOK_SECRET
+    );
+  } catch (err) {
+    throw new Error(`Webhook signature verification failed: ${err.message}`);
+  }
+  
+  // Handle the event
+  switch (event.type) {
+    case 'checkout.session.completed': {
+      const session = event.data.object;
+      const planId = session.metadata.planId;
+      const customerId = session.customer;
+      const subscriptionId = session.subscription;
+      
+      // Activate the plan
+      setCurrentPlan(planId, {
+        customerId,
+        subscriptionId,
+      });
+      
+      return {
+        success: true,
+        planId,
+        customerId,
+      };
+    }
+    
+    case 'customer.subscription.updated':
+    case 'customer.subscription.deleted': {
+      const subscription = event.data.object;
+      const customerId = subscription.customer;
+      
+      if (subscription.status === 'active') {
+        // Keep subscription active
+        return { success: true, status: 'active' };
+      } else if (['canceled', 'unpaid'].includes(subscription.status)) {
+        // Downgrade to FREE
+        setCurrentPlan('free');
+        return { success: true, status: 'downgraded' };
+      }
+      
+      return { success: true, status: subscription.status };
+    }
+    
+    default:
+      console.log(`Unhandled event type: ${event.type}`);
+      return { success: true, ignored: true };
+  }
+}
+
+/**
+ * Get Stripe public key for client-side
+ */
+function getStripePublicKey() {
+  return STRIPE_PUBLIC_KEY;
+}
+
+/**
+ * Create customer portal session
+ * Allows users to manage their subscription
+ */
+async function createPortalSession(customerId, returnUrl) {
+  if (!STRIPE_SECRET_KEY) {
+    throw new Error('Stripe is not configured');
+  }
+  
+  const stripe = require('stripe')(STRIPE_SECRET_KEY);
+  
+  const session = await stripe.billingPortal.sessions.create({
+    customer: customerId,
+    return_url: returnUrl,
+  });
+  
+  return {
+    url: session.url,
+  };
+}
+
+/**
+ * Verify Stripe is configured
+ */
+function isStripeConfigured() {
+  return !!(STRIPE_SECRET_KEY && STRIPE_PUBLIC_KEY);
+}
+
+/**
+ * Get checkout URL for a plan
+ * Helper for CLI
+ */
+function getCheckoutUrl(planId) {
+  const baseUrl = process.env.GUARDIAN_WEBSITE_URL || 'https://guardian.odavl.com';
+  return `${baseUrl}/checkout?plan=${planId}`;
+}
+
+module.exports = {
+  createCheckoutSession,
+  handleWebhook,
+  getStripePublicKey,
+  createPortalSession,
+  isStripeConfigured,
+  getCheckoutUrl,
+};

package/src/plans/plan-definitions.js

@@ -0,0 +1,148 @@
+/**
+ * ODAVL Guardian Plan Definitions
+ * Real enforced limits for FREE, PRO, and BUSINESS plans
+ */
+
+const PLANS = {
+  FREE: {
+    id: 'free',
+    name: 'Free',
+    price: 0,
+    priceMonthly: 0,
+    maxScansPerMonth: 10,
+    maxSites: 1,
+    liveGuardianAllowed: false,
+    ciModeAllowed: false,
+    alertsAllowed: false,
+    features: [
+      'Scan public pages',
+      'Basic issue detection',
+      'CLI usage',
+      'Community support',
+    ],
+  },
+  PRO: {
+    id: 'pro',
+    name: 'Pro',
+    price: 29,
+    priceMonthly: 29,
+    stripePriceId: process.env.STRIPE_PRO_PRICE_ID || 'price_pro_placeholder',
+    maxScansPerMonth: 200,
+    maxSites: 3,
+    liveGuardianAllowed: true,
+    ciModeAllowed: true,
+    alertsAllowed: true,
+    features: [
+      'Deeper checks & signals',
+      'Prioritized findings',
+      'Live guardian monitoring',
+      'CI/CD integration',
+      'Email alerts',
+      'Exportable reports',
+    ],
+  },
+  BUSINESS: {
+    id: 'business',
+    name: 'Business',
+    price: 99,
+    priceMonthly: 99,
+    stripePriceId: process.env.STRIPE_BUSINESS_PRICE_ID || 'price_business_placeholder',
+    maxScansPerMonth: -1, // unlimited
+    maxSites: -1, // unlimited
+    liveGuardianAllowed: true,
+    ciModeAllowed: true,
+    alertsAllowed: true,
+    features: [
+      'Everything in Pro',
+      'Unlimited scans',
+      'Unlimited sites',
+      'Priority support',
+      'Custom integrations',
+      'Team collaboration',
+    ],
+  },
+};
+
+/**
+ * Get plan by ID
+ */
+function getPlan(planId) {
+  const normalizedId = planId.toUpperCase();
+  if (!PLANS[normalizedId]) {
+    return PLANS.FREE;
+  }
+  return PLANS[normalizedId];
+}
+
+/**
+ * Check if a plan allows a specific feature
+ */
+function planAllows(planId, feature) {
+  const plan = getPlan(planId);
+  switch (feature) {
+    case 'liveGuardian':
+      return plan.liveGuardianAllowed;
+    case 'ciMode':
+      return plan.ciModeAllowed;
+    case 'alerts':
+      return plan.alertsAllowed;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Check if usage is within plan limits
+ */
+function isWithinLimit(planId, currentUsage, limitType) {
+  const plan = getPlan(planId);
+  
+  switch (limitType) {
+    case 'scans':
+      if (plan.maxScansPerMonth === -1) return true; // unlimited
+      return currentUsage < plan.maxScansPerMonth;
+    case 'sites':
+      if (plan.maxSites === -1) return true; // unlimited
+      return currentUsage < plan.maxSites;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Get human-readable error message for limit exceeded
+ */
+function getLimitExceededMessage(planId, limitType) {
+  const plan = getPlan(planId);
+  
+  switch (limitType) {
+    case 'scans':
+      return `You've reached your monthly scan limit for the ${plan.name} plan (${plan.maxScansPerMonth} scans/month). Upgrade to continue scanning.`;
+    case 'sites':
+      return `You've reached your site limit for the ${plan.name} plan (${plan.maxSites} site${plan.maxSites > 1 ? 's' : ''}). Upgrade to add more sites.`;
+    case 'liveGuardian':
+      return `Live Guardian monitoring is not available on the ${plan.name} plan. Upgrade to Pro to enable continuous monitoring.`;
+    case 'ciMode':
+      return `CI/CD mode is not available on the ${plan.name} plan. Upgrade to Pro to enable CI integration.`;
+    case 'alerts':
+      return `Email alerts are not available on the ${plan.name} plan. Upgrade to Pro to enable notifications.`;
+    default:
+      return `This feature is not available on your current plan. Upgrade to unlock more features.`;
+  }
+}
+
+/**
+ * Get all plans for display
+ */
+function getAllPlans() {
+  return [PLANS.FREE, PLANS.PRO, PLANS.BUSINESS];
+}
+
+module.exports = {
+  PLANS,
+  getPlan,
+  planAllows,
+  isWithinLimit,
+  getLimitExceededMessage,
+  getAllPlans,
+};

package/src/plans/plan-manager.js

@@ -0,0 +1,211 @@
+/**
+ * ODAVL Guardian Plan Manager
+ * Manages user plans, checks limits, and enforces restrictions
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getPlan, planAllows, isWithinLimit, getLimitExceededMessage } = require('./plan-definitions');
+const { getUsageStats, canPerformScan, canAddSite, recordScan } = require('./usage-tracker');
+
+const PLAN_DIR = path.join(os.homedir(), '.odavl-guardian', 'plan');
+const PLAN_FILE = path.join(PLAN_DIR, 'current-plan.json');
+
+/**
+ * Ensure plan directory exists
+ */
+function ensurePlanDir() {
+  if (!fs.existsSync(PLAN_DIR)) {
+    fs.mkdirSync(PLAN_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get current plan
+ */
+function getCurrentPlan() {
+  ensurePlanDir();
+  
+  if (!fs.existsSync(PLAN_FILE)) {
+    // Default to FREE plan
+    return {
+      planId: 'free',
+      activated: new Date().toISOString(),
+      stripeCustomerId: null,
+      stripeSubscriptionId: null,
+    };
+  }
+  
+  try {
+    return JSON.parse(fs.readFileSync(PLAN_FILE, 'utf-8'));
+  } catch (error) {
+    console.error('Error loading plan:', error.message);
+    return {
+      planId: 'free',
+      activated: new Date().toISOString(),
+      stripeCustomerId: null,
+      stripeSubscriptionId: null,
+    };
+  }
+}
+
+/**
+ * Set current plan
+ */
+function setCurrentPlan(planId, stripeData = {}) {
+  ensurePlanDir();
+  
+  const planInfo = {
+    planId: planId.toLowerCase(),
+    activated: new Date().toISOString(),
+    stripeCustomerId: stripeData.customerId || null,
+    stripeSubscriptionId: stripeData.subscriptionId || null,
+    upgraded: new Date().toISOString(),
+  };
+  
+  fs.writeFileSync(PLAN_FILE, JSON.stringify(planInfo, null, 2), 'utf-8');
+  return planInfo;
+}
+
+/**
+ * Check if a feature is allowed
+ */
+function checkFeatureAllowed(feature) {
+  const currentPlan = getCurrentPlan();
+  const plan = getPlan(currentPlan.planId);
+  const allowed = planAllows(currentPlan.planId, feature);
+  
+  return {
+    allowed,
+    plan: plan.name,
+    message: allowed ? null : getLimitExceededMessage(currentPlan.planId, feature),
+  };
+}
+
+/**
+ * Check if can perform scan
+ */
+function checkCanScan(url) {
+  const currentPlan = getCurrentPlan();
+  const plan = getPlan(currentPlan.planId);
+  const usage = getUsageStats();
+  
+  // Check site limit first
+  if (!canAddSite(url, plan.maxSites)) {
+    return {
+      allowed: false,
+      reason: 'site_limit',
+      message: getLimitExceededMessage(currentPlan.planId, 'sites'),
+      plan: plan.name,
+      usage: {
+        sites: usage.sites.length,
+        maxSites: plan.maxSites,
+      },
+    };
+  }
+  
+  // Check scan limit
+  if (!canPerformScan(plan.maxScansPerMonth)) {
+    return {
+      allowed: false,
+      reason: 'scan_limit',
+      message: getLimitExceededMessage(currentPlan.planId, 'scans'),
+      plan: plan.name,
+      usage: {
+        scansThisMonth: usage.scansThisMonth,
+        maxScans: plan.maxScansPerMonth,
+      },
+    };
+  }
+  
+  return {
+    allowed: true,
+    plan: plan.name,
+    usage: {
+      scansThisMonth: usage.scansThisMonth,
+      maxScans: plan.maxScansPerMonth,
+      scansRemaining: plan.maxScansPerMonth === -1 ? 'Unlimited' : plan.maxScansPerMonth - usage.scansThisMonth,
+    },
+  };
+}
+
+/**
+ * Record scan and enforce limits
+ */
+function performScan(url) {
+  const check = checkCanScan(url);
+  
+  if (!check.allowed) {
+    throw new Error(check.message);
+  }
+  
+  // Record the scan
+  recordScan(url);
+  
+  return {
+    success: true,
+    plan: check.plan,
+    usage: getUsageStats(),
+  };
+}
+
+/**
+ * Get plan summary for display
+ */
+function getPlanSummary() {
+  const currentPlan = getCurrentPlan();
+  const plan = getPlan(currentPlan.planId);
+  const usage = getUsageStats();
+  
+  return {
+    plan: {
+      id: plan.id,
+      name: plan.name,
+      price: plan.price,
+    },
+    limits: {
+      scans: {
+        max: plan.maxScansPerMonth,
+        used: usage.scansThisMonth,
+        remaining: plan.maxScansPerMonth === -1 ? 'Unlimited' : Math.max(0, plan.maxScansPerMonth - usage.scansThisMonth),
+      },
+      sites: {
+        max: plan.maxSites,
+        used: usage.sites.length,
+        remaining: plan.maxSites === -1 ? 'Unlimited' : Math.max(0, plan.maxSites - usage.sites.length),
+      },
+    },
+    features: {
+      liveGuardian: plan.liveGuardianAllowed,
+      ciMode: plan.ciModeAllowed,
+      alerts: plan.alertsAllowed,
+    },
+    activated: currentPlan.activated,
+  };
+}
+
+/**
+ * Upgrade message helper
+ */
+function getUpgradeMessage() {
+  return '\nTo upgrade your plan, visit: https://guardian.odavl.com/pricing\nOr run: guardian upgrade';
+}
+
+/**
+ * Get plan file path (for debugging)
+ */
+function getPlanFilePath() {
+  return PLAN_FILE;
+}
+
+module.exports = {
+  getCurrentPlan,
+  setCurrentPlan,
+  checkFeatureAllowed,
+  checkCanScan,
+  performScan,
+  getPlanSummary,
+  getUpgradeMessage,
+  getPlanFilePath,
+};