@odavl/guardian 0.2.0 → 1.0.0

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,
+};

package/src/plans/usage-tracker.js

@@ -0,0 +1,210 @@
+/**
+ * ODAVL Guardian Usage Tracker
+ * Tracks scans per month and enforces plan limits
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const USAGE_DIR = path.join(os.homedir(), '.odavl-guardian', 'usage');
+const USAGE_FILE = path.join(USAGE_DIR, 'usage.json');
+
+/**
+ * Ensure usage directory exists
+ */
+function ensureUsageDir() {
+  if (!fs.existsSync(USAGE_DIR)) {
+    fs.mkdirSync(USAGE_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get current month key (YYYY-MM)
+ */
+function getCurrentMonthKey() {
+  const now = new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+}
+
+/**
+ * Load usage data
+ */
+function loadUsage() {
+  ensureUsageDir();
+  
+  if (!fs.existsSync(USAGE_FILE)) {
+    return {
+      currentMonth: getCurrentMonthKey(),
+      scansThisMonth: 0,
+      sites: [],
+      totalScans: 0,
+      history: {},
+    };
+  }
+  
+  try {
+    const data = JSON.parse(fs.readFileSync(USAGE_FILE, 'utf-8'));
+    
+    // Reset if new month
+    const currentMonth = getCurrentMonthKey();
+    if (data.currentMonth !== currentMonth) {
+      // Archive old month
+      data.history[data.currentMonth] = {
+        scans: data.scansThisMonth,
+        sites: data.sites.length,
+      };
+      
+      // Reset for new month
+      data.currentMonth = currentMonth;
+      data.scansThisMonth = 0;
+    }
+    
+    return data;
+  } catch (error) {
+    console.error('Error loading usage data:', error.message);
+    return {
+      currentMonth: getCurrentMonthKey(),
+      scansThisMonth: 0,
+      sites: [],
+      totalScans: 0,
+      history: {},
+    };
+  }
+}
+
+/**
+ * Save usage data
+ */
+function saveUsage(usage) {
+  ensureUsageDir();
+  fs.writeFileSync(USAGE_FILE, JSON.stringify(usage, null, 2), 'utf-8');
+}
+
+/**
+ * Record a scan
+ */
+function recordScan(url) {
+  const usage = loadUsage();
+  
+  // Extract domain from URL
+  let domain;
+  try {
+    const urlObj = new URL(url);
+    domain = urlObj.hostname;
+  } catch {
+    domain = url;
+  }
+  
+  // Increment scan count
+  usage.scansThisMonth += 1;
+  usage.totalScans += 1;
+  
+  // Track unique site
+  if (!usage.sites.includes(domain)) {
+    usage.sites.push(domain);
+  }
+  
+  // Record timestamp
+  if (!usage.scanHistory) {
+    usage.scanHistory = [];
+  }
+  usage.scanHistory.push({
+    url,
+    domain,
+    timestamp: new Date().toISOString(),
+  });
+  
+  // Keep only last 100 scans in history
+  if (usage.scanHistory.length > 100) {
+    usage.scanHistory = usage.scanHistory.slice(-100);
+  }
+  
+  saveUsage(usage);
+  return usage;
+}
+
+/**
+ * Get current usage stats
+ */
+function getUsageStats() {
+  return loadUsage();
+}
+
+/**
+ * Get scans remaining for current plan
+ */
+function getScansRemaining(maxScans) {
+  const usage = loadUsage();
+  if (maxScans === -1) return 'Unlimited';
+  return Math.max(0, maxScans - usage.scansThisMonth);
+}
+
+/**
+ * Check if can perform scan
+ */
+function canPerformScan(maxScans) {
+  if (maxScans === -1) return true; // unlimited
+  const usage = loadUsage();
+  return usage.scansThisMonth < maxScans;
+}
+
+/**
+ * Check if can add site
+ */
+function canAddSite(url, maxSites) {
+  if (maxSites === -1) return true; // unlimited
+  
+  const usage = loadUsage();
+  
+  // Extract domain
+  let domain;
+  try {
+    const urlObj = new URL(url);
+    domain = urlObj.hostname;
+  } catch {
+    domain = url;
+  }
+  
+  // If site already tracked, it's OK
+  if (usage.sites.includes(domain)) {
+    return true;
+  }
+  
+  // Check if under limit
+  return usage.sites.length < maxSites;
+}
+
+/**
+ * Reset usage (for testing or manual reset)
+ */
+function resetUsage() {
+  ensureUsageDir();
+  const usage = {
+    currentMonth: getCurrentMonthKey(),
+    scansThisMonth: 0,
+    sites: [],
+    totalScans: 0,
+    history: {},
+    scanHistory: [],
+  };
+  saveUsage(usage);
+  return usage;
+}
+
+/**
+ * Get usage file path (for debugging)
+ */
+function getUsageFilePath() {
+  return USAGE_FILE;
+}
+
+module.exports = {
+  recordScan,
+  getUsageStats,
+  getScansRemaining,
+  canPerformScan,
+  canAddSite,
+  resetUsage,
+  getUsageFilePath,
+};