Feature/razorpay integration

.env.example

@@ -29,8 +29,26 @@ WS_PORT=3001
 # Logging
 LOG_LEVEL=debug
 
-# Slack Integration (Phase 3 - Optional)
+# Slack Integration (Optional)
 # Create a Slack App at https://api.slack.com/apps
 SLACK_CLIENT_ID=
 SLACK_CLIENT_SECRET=
 SLACK_SIGNING_SECRET=
+
+# Razorpay Billing 
+# Get your API keys from https://dashboard.razorpay.com/#/app/keys
+RAZORPAY_KEY_ID=your_razorpay_key_id
+RAZORPAY_KEY_SECRET=your_razorpay_key_secret
+RAZORPAY_WEBHOOK_SECRET=your_razorpay_webhook_secret
+
+# Razorpay Plan IDs 
+RAZORPAY_PRO_MONTHLY_PLAN_ID=plan_pro_monthly
+RAZORPAY_PRO_ANNUAL_PLAN_ID=plan_pro_annual
+RAZORPAY_TEAM_MONTHLY_PLAN_ID=plan_team_monthly
+RAZORPAY_TEAM_ANNUAL_PLAN_ID=plan_team_annual
+
+# Web App URL (for redirect URLs)
+WEB_APP_URL=http://localhost:3000
+
+# Frontend Environment Variables
+NEXT_PUBLIC_RAZORPAY_KEY_ID=your_razorpay_key_id

.gitignore

@@ -47,4 +47,6 @@ coverage/
 docker-compose.override.yml
 apps/server/src/generated/
 
-rules/
+rules/
+docs/
+opencode.jsonc

apps/extension/src/extension.ts

@@ -11,6 +11,7 @@ import * as vscode from 'vscode';
 
 import { ActivityTracker } from './services/activityTracker';
 import { AuthService } from './services/authService';
+import { FeatureGatingService } from './services/featureGatingService';
 import { FriendRequestService } from './services/friendRequestService';
 import { WebSocketClient } from './services/wsClient';
 import { ConfigManager } from './utils/configManager';
@@ -48,6 +49,8 @@ class DevRadarExtension implements vscode.Disposable {
   private readonly statsProvider: StatsProvider;
   private readonly leaderboardProvider: LeaderboardProvider;
   private statsRefreshInterval: NodeJS.Timeout | null = null;
+  // Phase 5: Feature Gating
+  private readonly featureGatingService: FeatureGatingService;
 
   constructor(context: vscode.ExtensionContext) {
     this.logger = new Logger('DevRadar');
@@ -77,6 +80,12 @@ class DevRadarExtension implements vscode.Disposable {
     // Phase 2: Gamification views
     this.statsProvider = new StatsProvider(this.logger);
     this.leaderboardProvider = new LeaderboardProvider(this.logger);
+    // Phase 5: Feature Gating
+    this.featureGatingService = new FeatureGatingService(
+      this.authService,
+      this.configManager,
+      this.logger
+    );
     /* Track disposables */
     this.disposables.push(
       this.authService,
@@ -89,7 +98,8 @@ class DevRadarExtension implements vscode.Disposable {
       this.statusBar,
       this.configManager,
       this.statsProvider,
-      this.leaderboardProvider
+      this.leaderboardProvider,
+      this.featureGatingService
     );
   }
 
@@ -194,6 +204,14 @@ class DevRadarExtension implements vscode.Disposable {
           void vscode.commands.executeCommand('devradar.friendRequests.focus');
         },
       },
+      {
+        id: 'devradar.enableGhostMode',
+        handler: () => this.handleEnableGhostMode(),
+      },
+      {
+        id: 'devradar.openBilling',
+        handler: () => this.handleOpenBilling(),
+      },
     ];
 
     for (const command of commands) {
@@ -761,6 +779,42 @@ class DevRadarExtension implements vscode.Disposable {
     }
   }
 
+  private async handleEnableGhostMode(): Promise<void> {
+    // Check if user has access to ghost mode feature
+    const hasAccess = await this.featureGatingService.promptUpgrade('ghostMode');
+    if (!hasAccess) {
+      return;
+    }
+
+    // Toggle ghost mode
+    const currentMode = this.configManager.get('privacyMode');
+    await this.configManager.update('privacyMode', !currentMode);
+
+    const message = !currentMode
+      ? 'DevRadar: Ghost mode enabled - you are now invisible to others'
+      : 'DevRadar: Ghost mode disabled - your activity is now visible';
+
+    void vscode.window.showInformationMessage(message);
+    this.activityTracker.sendStatusUpdate();
+  }
+
+  private async handleOpenBilling(): Promise<void> {
+    const webAppUrl = this.getWebAppUrl();
+    const tier = this.featureGatingService.getCurrentTier();
+    const billingUrl = `${webAppUrl}/dashboard/billing?current=${tier}`;
+
+    await vscode.env.openExternal(vscode.Uri.parse(billingUrl));
+    this.logger.info('Opened billing page', { currentTier: tier });
+  }
+
+  private getWebAppUrl(): string {
+    const serverUrl = this.configManager.get('serverUrl');
+    if (serverUrl.includes('localhost') || serverUrl.includes('127.0.0.1')) {
+      return 'http://localhost:3001';
+    }
+    return 'https://devradar.dev';
+  }
+
   dispose(): void {
     this.logger.info('Disposing DevRadar extension...');
 

apps/extension/src/services/featureGatingService.ts

@@ -0,0 +1,234 @@
+/**
+ * Feature Gating Service
+ *
+ * Client-side feature access control for the VS Code extension.
+ * Checks user tier and prompts for upgrade when accessing gated features.
+ */
+
+import * as vscode from 'vscode';
+
+import type { AuthService } from './authService';
+import type { ConfigManager } from '../utils/configManager';
+import type { Logger } from '../utils/logger';
+
+type Feature =
+  | 'presence'
+  | 'friends'
+  | 'globalLeaderboard'
+  | 'friendsLeaderboard'
+  | 'streaks'
+  | 'achievements'
+  | 'poke'
+  | 'privacyMode'
+  | 'unlimitedFriends'
+  | 'ghostMode'
+  | 'customStatus'
+  | 'history30d'
+  | 'themes'
+  | 'customEmoji'
+  | 'prioritySupport'
+  | 'conflictRadar'
+  | 'teamCreation'
+  | 'teamAnalytics'
+  | 'slackIntegration'
+  | 'privateLeaderboards'
+  | 'adminControls'
+  | 'ssoSaml'
+  | 'dedicatedSupport';
+
+type SubscriptionTier = 'FREE' | 'PRO' | 'TEAM';
+
+const FREE_FEATURES: readonly Feature[] = [
+  'presence',
+  'friends',
+  'globalLeaderboard',
+  'friendsLeaderboard',
+  'streaks',
+  'achievements',
+  'poke',
+  'privacyMode',
+];
+
+const PRO_ADDITIONAL: readonly Feature[] = [
+  'unlimitedFriends',
+  'ghostMode',
+  'customStatus',
+  'history30d',
+  'themes',
+  'customEmoji',
+  'prioritySupport',
+];
+
+const TEAM_ADDITIONAL: readonly Feature[] = [
+  'conflictRadar',
+  'teamCreation',
+  'teamAnalytics',
+  'slackIntegration',
+  'privateLeaderboards',
+  'adminControls',
+  'ssoSaml',
+  'dedicatedSupport',
+];
+
+const SUBSCRIPTION_FEATURES: Record<SubscriptionTier, readonly Feature[]> = {
+  FREE: FREE_FEATURES,
+  PRO: [...FREE_FEATURES, ...PRO_ADDITIONAL],
+  TEAM: [...FREE_FEATURES, ...PRO_ADDITIONAL, ...TEAM_ADDITIONAL],
+};
+
+const FEATURE_TIER_MAP: Record<Feature, SubscriptionTier> = {
+  presence: 'FREE',
+  friends: 'FREE',
+  globalLeaderboard: 'FREE',
+  friendsLeaderboard: 'FREE',
+  streaks: 'FREE',
+  achievements: 'FREE',
+  poke: 'FREE',
+  privacyMode: 'FREE',
+  unlimitedFriends: 'PRO',
+  ghostMode: 'PRO',
+  customStatus: 'PRO',
+  history30d: 'PRO',
+  themes: 'PRO',
+  customEmoji: 'PRO',
+  prioritySupport: 'PRO',
+  conflictRadar: 'TEAM',
+  teamCreation: 'TEAM',
+  teamAnalytics: 'TEAM',
+  slackIntegration: 'TEAM',
+  privateLeaderboards: 'TEAM',
+  adminControls: 'TEAM',
+  ssoSaml: 'TEAM',
+  dedicatedSupport: 'TEAM',
+};
+
+const FEATURE_DESCRIPTIONS: Record<Feature, string> = {
+  presence: 'Real-time presence status',
+  friends: 'Friends list with activity',
+  globalLeaderboard: 'Global coding leaderboards',
+  friendsLeaderboard: 'Friends leaderboard',
+  streaks: 'Coding streak tracking',
+  achievements: 'GitHub achievements',
+  poke: 'Poke friends',
+  privacyMode: 'Hide activity details',
+  unlimitedFriends: 'Unlimited friends',
+  ghostMode: 'Go completely invisible',
+  customStatus: 'Custom status messages',
+  history30d: '30-day activity history',
+  themes: 'Custom themes',
+  customEmoji: 'Custom emoji reactions',
+  prioritySupport: 'Priority support',
+  conflictRadar: 'Merge conflict detection',
+  teamCreation: 'Create and manage teams',
+  teamAnalytics: 'Team analytics dashboard',
+  slackIntegration: 'Slack integration',
+  privateLeaderboards: 'Private team leaderboards',
+  adminControls: 'Admin controls',
+  ssoSaml: 'SSO & SAML authentication',
+  dedicatedSupport: 'Dedicated support',
+};
+
+/** Manages feature access control and upgrade prompts. */
+export class FeatureGatingService implements vscode.Disposable {
+  private readonly disposables: vscode.Disposable[] = [];
+
+  constructor(
+    private readonly authService: AuthService,
+    private readonly configManager: ConfigManager,
+    private readonly logger: Logger
+  ) {}
+
+  /**
+   * Checks if the current user has access to a feature.
+   * @param feature - The feature to check access for
+   * @returns true if the user has access
+   */
+  hasAccess(feature: Feature): boolean {
+    const user = this.authService.getUser();
+    if (!user) {
+      return false;
+    }
+
+    // Defensive: ensure tier is valid, default to FREE if not
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime value might differ from type
+    const tier = (user.tier ?? 'FREE') as SubscriptionTier;
+    return SUBSCRIPTION_FEATURES[tier].includes(feature);
+  }
+
+  /**
+   * Gets the minimum tier required for a feature.
+   * @param feature - The feature to check
+   * @returns The minimum tier required
+   */
+  getRequiredTier(feature: Feature): SubscriptionTier {
+    return FEATURE_TIER_MAP[feature];
+  }
+
+  /**
+   * Gets the user's current tier.
+   * @returns The user's tier or 'FREE' if not authenticated
+   */
+  getCurrentTier(): SubscriptionTier {
+    const user = this.authService.getUser();
+    return (user?.tier ?? 'FREE') as SubscriptionTier;
+  }
+
+  /**
+   * Prompts the user to upgrade if they don't have access to a feature.
+   * Opens the billing page in the browser with upgrade parameters.
+   *
+   * @param feature - The feature requiring upgrade
+   * @returns true if the user has access, false if they need to upgrade
+   */
+  async promptUpgrade(feature: Feature): Promise<boolean> {
+    if (this.hasAccess(feature)) {
+      return true;
+    }
+
+    const requiredTier = this.getRequiredTier(feature);
+    const featureDescription = FEATURE_DESCRIPTIONS[feature];
+
+    const action = await vscode.window.showWarningMessage(
+      `DevRadar: "${featureDescription}" requires ${requiredTier} tier.`,
+      'Upgrade Now',
+      'Maybe Later'
+    );
+
+    if (action === 'Upgrade Now') {
+      const webAppUrl = this.getWebAppUrl();
+      const upgradeUrl = `${webAppUrl}/dashboard/billing?upgrade=${requiredTier}&feature=${feature}`;
+
+      await vscode.env.openExternal(vscode.Uri.parse(upgradeUrl));
+      this.logger.info('Opened upgrade page', { feature, requiredTier });
+    }
+
+    return false;
+  }
+
+  /**
+   * Gets the upgrade URL for a specific tier.
+   * @param tier - The target tier
+   * @returns The full upgrade URL
+   */
+  getUpgradeUrl(tier: SubscriptionTier): string {
+    const webAppUrl = this.getWebAppUrl();
+    return `${webAppUrl}/dashboard/billing?upgrade=${tier}`;
+  }
+
+  /**
+   * Gets the web app URL from config or uses default.
+   */
+  private getWebAppUrl(): string {
+    const serverUrl = this.configManager.get('serverUrl');
+    if (serverUrl.includes('localhost') || serverUrl.includes('127.0.0.1')) {
+      return 'http://localhost:3001';
+    }
+    return 'https://devradar.dev';
+  }
+
+  dispose(): void {
+    for (const disposable of this.disposables) {
+      disposable.dispose();
+    }
+  }
+}

apps/extension/src/services/index.ts

@@ -2,3 +2,4 @@ export { AuthService, type AuthState } from './authService';
 export { WebSocketClient, type ConnectionState } from './wsClient';
 export { ActivityTracker } from './activityTracker';
 export { FriendRequestService } from './friendRequestService';
+export { FeatureGatingService } from './featureGatingService';