spaps 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spaps",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Sweet Potato Authentication & Payment Service CLI - Zero-config local development and project scaffolding",
   "main": "bin/spaps.js",
   "bin": {
@@ -37,13 +37,14 @@
   },
   "homepage": "https://sweetpotato.dev",
   "dependencies": {
+    "axios": "^1.6.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
     "ora": "^5.4.1",
     "prompts": "^2.4.2",
-    "axios": "^1.6.0",
-    "express": "^4.18.2",
-    "cors": "^2.8.5"
+    "stripe": "^18.5.0"
   },
   "engines": {
     "node": ">=16.0.0"

package/src/local-server.js

@@ -12,6 +12,11 @@ const { generateDocsHTML } = require('./docs-html');
 const StripeLocalManager = require('./stripe-local');
 const LocalAdminManager = require('./admin-local');
 
+// Stripe configuration for test mode
+const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY || 'sk_test_51S1WOy2HT0E1dOewiHvzt7T96PDwjocSDDUuc2ur569AVA5fDj4UpNM66lujrda1tTYrgooG0Z1dNFZfwEZuZdcA00nuVLJW67');
+const STRIPE_PUBLISHABLE_KEY = process.env.STRIPE_PUBLISHABLE_KEY || 'pk_test_51S1WOy2HT0E1dOewb2EkxZIaPkz7v3zMM9VxuBoxgNILYMmS85I4zrAWTkevyUQcaWlWUoC2NYnB8X5ZKd5e7Ifc005IzIW6H2';
+const USE_REAL_STRIPE = process.env.USE_REAL_STRIPE !== 'false'; // Default to true
+
 class LocalServer {
   constructor(options = {}) {
     this.port = options.port || process.env.PORT || 3456;
@@ -147,20 +152,74 @@ class LocalServer {
       });
     });
 
-    // Mock Stripe checkout sessions endpoint (SDK expects this path)
-    this.app.post('/api/stripe/checkout-sessions', (req, res) => {
-      const sessionId = 'cs_local_' + Date.now();
-      res.json({
-        success: true,
-        data: {
-          sessionId,
-          url: `http://localhost:${this.port}/checkout/${sessionId}?success=${encodeURIComponent(req.body.success_url)}&cancel=${encodeURIComponent(req.body.cancel_url)}`,
-          amount_total: req.body.amount || 999,
-          currency: req.body.currency || 'usd',
-          payment_status: 'unpaid',
-          status: 'open'
+    // Stripe checkout sessions endpoint - REAL or MOCK based on config
+    this.app.post('/api/stripe/checkout-sessions', async (req, res) => {
+      try {
+        if (USE_REAL_STRIPE) {
+          // Real Stripe checkout session
+          const { product_name, amount, currency = 'usd', success_url, cancel_url, price_id } = req.body;
+          
+          let lineItems;
+          if (price_id) {
+            // Use existing price
+            lineItems = [{ price: price_id, quantity: 1 }];
+          } else {
+            // Create price on the fly
+            lineItems = [{
+              price_data: {
+                currency,
+                product_data: { name: product_name || 'Product' },
+                unit_amount: amount || 999
+              },
+              quantity: 1
+            }];
+          }
+
+          const session = await stripe.checkout.sessions.create({
+            mode: 'payment',
+            line_items: lineItems,
+            success_url,
+            cancel_url,
+            automatic_tax: { enabled: false },
+            customer_creation: 'always'
+          });
+
+          res.json({
+            success: true,
+            data: {
+              sessionId: session.id,
+              url: session.url,
+              amount_total: session.amount_total,
+              currency: session.currency,
+              payment_status: session.payment_status,
+              status: session.status
+            }
+          });
+        } else {
+          // Mock response (fallback)
+          const sessionId = 'cs_local_' + Date.now();
+          res.json({
+            success: true,
+            data: {
+              sessionId,
+              url: `http://localhost:${this.port}/checkout/${sessionId}?success=${encodeURIComponent(req.body.success_url)}&cancel=${encodeURIComponent(req.body.cancel_url)}`,
+              amount_total: req.body.amount || 999,
+              currency: req.body.currency || 'usd',
+              payment_status: 'unpaid',
+              status: 'open'
+            }
+          });
         }
-      });
+      } catch (error) {
+        console.error('Stripe checkout error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'CHECKOUT_ERROR',
+            message: error.message || 'Failed to create checkout session'
+          }
+        });
+      }
     });
 
     // Mock Stripe endpoints (legacy)
@@ -180,29 +239,77 @@ class LocalServer {
       });
     });
 
-    // Mock Stripe products endpoint
-    this.app.get('/api/stripe/products', (req, res) => {
-      res.json({
-        success: true,
-        data: [
-          {
-            id: 'prod_local_validate',
-            name: 'Validate',
-            description: 'Proof of concept validation',
-            price: 500,
-            currency: 'usd',
-            active: true
-          },
-          {
-            id: 'prod_local_prototype', 
-            name: 'Prototype',
-            description: 'Build an MVP prototype',
-            price: 2500,
-            currency: 'usd',
-            active: true
+    // Stripe products endpoint - REAL or MOCK based on config
+    this.app.get('/api/stripe/products', async (req, res) => {
+      try {
+        if (USE_REAL_STRIPE) {
+          // Fetch real Stripe products
+          const products = await stripe.products.list({
+            active: req.query.active !== undefined ? req.query.active === 'true' : undefined,
+            limit: req.query.limit ? parseInt(req.query.limit) : 10
+          });
+
+          // Get prices for each product
+          const productsWithPrices = await Promise.all(
+            products.data.map(async (product) => {
+              const prices = await stripe.prices.list({
+                product: product.id,
+                active: true,
+                limit: 1
+              });
+              
+              const defaultPrice = prices.data[0];
+              return {
+                id: product.id,
+                name: product.name,
+                description: product.description,
+                price: defaultPrice ? defaultPrice.unit_amount : 0,
+                currency: defaultPrice ? defaultPrice.currency : 'usd',
+                price_id: defaultPrice ? defaultPrice.id : null,
+                active: product.active,
+                metadata: product.metadata
+              };
+            })
+          );
+
+          res.json({
+            success: true,
+            data: productsWithPrices
+          });
+        } else {
+          // Mock response (fallback)
+          res.json({
+            success: true,
+            data: [
+              {
+                id: 'prod_local_validate',
+                name: 'Validate',
+                description: 'Proof of concept validation',
+                price: 500,
+                currency: 'usd',
+                active: true
+              },
+              {
+                id: 'prod_local_prototype', 
+                name: 'Prototype',
+                description: 'Build an MVP prototype',
+                price: 2500,
+                currency: 'usd',
+                active: true
+              }
+            ]
+          });
+        }
+      } catch (error) {
+        console.error('Stripe products error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'PRODUCTS_ERROR', 
+            message: error.message || 'Failed to fetch products'
           }
-        ]
-      });
+        });
+      }
     });
 
     // Mock auth nonce endpoint
@@ -242,16 +349,111 @@ class LocalServer {
       });
     });
 
-    // Mock admin product sync endpoint
-    this.app.post('/api/v1/admin/products/sync', (req, res) => {
-      res.json({
-        success: true,
-        message: 'Products synced successfully (local mode)',
-        data: {
-          synced_count: 2,
-          products: ['Validate', 'Prototype']
+    // Admin product sync endpoint - REAL or MOCK based on config
+    this.app.post('/api/v1/admin/products/sync', async (req, res) => {
+      try {
+        if (USE_REAL_STRIPE) {
+          // Get local products from admin manager
+          const localProducts = this.adminManager.listProducts();
+          const syncResults = [];
+
+          for (const product of localProducts) {
+            try {
+              // Check if product already exists in Stripe
+              let stripeProduct;
+              try {
+                stripeProduct = await stripe.products.retrieve(product.id);
+              } catch (error) {
+                if (error.code === 'resource_missing') {
+                  // Create new product in Stripe
+                  stripeProduct = await stripe.products.create({
+                    id: product.id,
+                    name: product.name,
+                    description: product.description,
+                    metadata: {
+                      spaps_managed: 'true',
+                      created_by: 'spaps_admin'
+                    }
+                  });
+
+                  // Create corresponding price
+                  await stripe.prices.create({
+                    id: product.price_id,
+                    product: stripeProduct.id,
+                    unit_amount: product.price,
+                    currency: product.currency,
+                    metadata: {
+                      spaps_managed: 'true'
+                    }
+                  });
+
+                  syncResults.push({
+                    id: product.id,
+                    name: product.name,
+                    action: 'created',
+                    stripe_id: stripeProduct.id
+                  });
+                } else {
+                  throw error;
+                }
+              }
+
+              if (stripeProduct && !syncResults.find(r => r.id === product.id)) {
+                // Update existing product
+                await stripe.products.update(stripeProduct.id, {
+                  name: product.name,
+                  description: product.description,
+                  active: product.active
+                });
+
+                syncResults.push({
+                  id: product.id,
+                  name: product.name,
+                  action: 'updated',
+                  stripe_id: stripeProduct.id
+                });
+              }
+            } catch (productError) {
+              console.error(`Error syncing product ${product.id}:`, productError);
+              syncResults.push({
+                id: product.id,
+                name: product.name,
+                action: 'error',
+                error: productError.message
+              });
+            }
+          }
+
+          res.json({
+            success: true,
+            message: `Successfully synced ${syncResults.filter(r => r.action !== 'error').length} products to Stripe`,
+            data: {
+              synced_count: syncResults.filter(r => r.action !== 'error').length,
+              total_count: localProducts.length,
+              results: syncResults
+            }
+          });
+        } else {
+          // Mock response (fallback)
+          res.json({
+            success: true,
+            message: 'Products synced successfully (mock mode)',
+            data: {
+              synced_count: 2,
+              products: ['Validate', 'Prototype']
+            }
+          });
         }
-      });
+      } catch (error) {
+        console.error('Product sync error:', error);
+        res.status(500).json({
+          success: false,
+          error: {
+            code: 'SYNC_ERROR',
+            message: error.message || 'Failed to sync products'
+          }
+        });
+      }
     });
 
     // Mock usage endpoints
@@ -389,19 +591,62 @@ class LocalServer {
       `);
     });
 
-    // Mock webhook endpoint
+    // Stripe webhook endpoint - REAL or MOCK based on config
     this.app.post('/api/stripe/webhooks', express.raw({ type: 'application/json' }), (req, res) => {
-      // In local mode, accept all webhooks
-      const event = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
-      
-      if (!this.json) {
-        console.log(chalk.blue(`⚡ Webhook received: ${event.type}`));
+      try {
+        let event;
+
+        if (USE_REAL_STRIPE) {
+          // Real Stripe webhook verification
+          const sig = req.headers['stripe-signature'];
+          const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+
+          if (webhookSecret && sig) {
+            try {
+              event = stripe.webhooks.constructEvent(req.body, sig, webhookSecret);
+            } catch (err) {
+              console.error('Webhook signature verification failed:', err.message);
+              return res.status(400).send(`Webhook Error: ${err.message}`);
+            }
+          } else {
+            // For local development without webhook secret
+            event = JSON.parse(req.body.toString());
+          }
+        } else {
+          // Mock mode - accept all webhooks
+          event = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
+        }
+
+        if (!this.json) {
+          console.log(chalk.blue(`⚡ Webhook received: ${event.type}`));
+        }
+
+        // Handle the event
+        switch (event.type) {
+          case 'checkout.session.completed':
+            const session = event.data.object;
+            console.log(chalk.green(`✅ Payment successful: ${session.id}`));
+            break;
+          case 'payment_intent.succeeded':
+            const paymentIntent = event.data.object;
+            console.log(chalk.green(`💰 Payment intent succeeded: ${paymentIntent.id}`));
+            break;
+          case 'customer.subscription.created':
+            const subscription = event.data.object;
+            console.log(chalk.green(`📋 Subscription created: ${subscription.id}`));
+            break;
+          default:
+            console.log(chalk.yellow(`🔔 Unhandled event type: ${event.type}`));
+        }
+        
+        // Store for testing
+        this.lastWebhookEvent = event;
+        
+        res.json({ received: true });
+      } catch (error) {
+        console.error('Webhook processing error:', error);
+        res.status(500).json({ error: error.message });
       }
-      
-      // Store for testing
-      this.lastWebhookEvent = event;
-      
-      res.json({ received: true });
     });
 
     // Webhook testing UI
@@ -787,6 +1032,11 @@ class LocalServer {
             console.log(chalk.yellow('🍠 SPAPS Local Development Server'));
             console.log(chalk.green(`✨ Running at: http://localhost:${this.port}`));
             console.log(chalk.blue(`📝 Documentation: http://localhost:${this.port}/docs`));
+            if (USE_REAL_STRIPE) {
+              console.log(chalk.magenta('💳 Stripe: Real test mode (live API calls)'));
+            } else {
+              console.log(chalk.gray('💳 Stripe: Mock mode (simulated responses)'));
+            }
             console.log(chalk.dim('   Press Ctrl+C to stop'));
             console.log();
           }