spaps 0.3.0 → 0.3.2

package/bin/spaps.js

@@ -34,7 +34,7 @@ program
 program
   .command('local')
   .description('Start local SPAPS server (no API keys required!)')
-  .option('-p, --port <port>', 'Port to run on', '3300')
+  .option('-p, --port <port>', 'Port to run on', '3456')
   .option('-o, --open', 'Open browser automatically', false)
   .option('--json', 'Output in JSON format')
   .action(async (options, command) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spaps",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Sweet Potato Authentication & Payment Service CLI - Zero-config local development and project scaffolding",
   "main": "bin/spaps.js",
   "bin": {

package/src/admin-local.js

@@ -0,0 +1,408 @@
+/**
+ * Local Admin Management for SPAPS
+ * Provides product, customer, and order management in local mode
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+class LocalAdminManager {
+  constructor(dataDir = './.spaps') {
+    this.dataDir = dataDir;
+    this.ensureDataDir();
+    this.loadData();
+  }
+
+  ensureDataDir() {
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+  }
+
+  loadData() {
+    // Load or create products
+    this.productsFile = path.join(this.dataDir, 'products.json');
+    if (fs.existsSync(this.productsFile)) {
+      this.products = JSON.parse(fs.readFileSync(this.productsFile, 'utf8'));
+    } else {
+      this.products = this.getDefaultProducts();
+      this.saveProducts();
+    }
+
+    // Load or create orders
+    this.ordersFile = path.join(this.dataDir, 'orders.json');
+    if (fs.existsSync(this.ordersFile)) {
+      this.orders = JSON.parse(fs.readFileSync(this.ordersFile, 'utf8'));
+    } else {
+      this.orders = [];
+      this.saveOrders();
+    }
+
+    // Load or create customers
+    this.customersFile = path.join(this.dataDir, 'customers.json');
+    if (fs.existsSync(this.customersFile)) {
+      this.customers = JSON.parse(fs.readFileSync(this.customersFile, 'utf8'));
+    } else {
+      this.customers = [];
+      this.saveCustomers();
+    }
+  }
+
+  getDefaultProducts() {
+    return [
+      {
+        id: 'prod_local_validate',
+        price_id: 'price_local_validate',
+        name: 'Validate Tier',
+        description: 'Landing page with data capture and analytics',
+        price: 50000,
+        currency: 'usd',
+        features: [
+          'Landing page',
+          'Data capture setup',
+          'Analytics integration',
+          'Deployment'
+        ],
+        active: true,
+        created_at: new Date().toISOString()
+      },
+      {
+        id: 'prod_local_prototype',
+        price_id: 'price_local_prototype',
+        name: 'Prototype Tier',
+        description: 'Clickable prototype with core user flows',
+        price: 250000,
+        currency: 'usd',
+        features: [
+          'Clickable interface',
+          'Core user flows',
+          'Demo environment',
+          'Shareable prototype link'
+        ],
+        active: true,
+        created_at: new Date().toISOString()
+      },
+      {
+        id: 'prod_local_strategy',
+        price_id: 'price_local_strategy',
+        name: 'Strategy Tier',
+        description: 'Technical architecture and implementation roadmap',
+        price: 1000000,
+        currency: 'usd',
+        features: [
+          'Technical architecture design',
+          'Development roadmap',
+          'Tech stack decisions',
+          'Implementation timeline'
+        ],
+        active: true,
+        created_at: new Date().toISOString()
+      },
+      {
+        id: 'prod_local_build',
+        price_id: 'price_local_build',
+        name: 'Build Tier',
+        description: 'Full application development and deployment',
+        price: 2500000,
+        currency: 'usd',
+        features: [
+          'Full application development',
+          'Database & backend',
+          'Production deployment',
+          'Technical handoff'
+        ],
+        active: true,
+        created_at: new Date().toISOString()
+      }
+    ];
+  }
+
+  // Product Management
+  
+  saveProducts() {
+    fs.writeFileSync(this.productsFile, JSON.stringify(this.products, null, 2));
+  }
+
+  listProducts(filter = {}) {
+    let filtered = [...this.products];
+    
+    if (filter.active !== undefined) {
+      filtered = filtered.filter(p => p.active === filter.active);
+    }
+    
+    return filtered;
+  }
+
+  getProduct(id) {
+    return this.products.find(p => p.id === id || p.price_id === id);
+  }
+
+  createProduct(data) {
+    const product = {
+      id: `prod_local_${uuidv4().substring(0, 8)}`,
+      price_id: `price_local_${uuidv4().substring(0, 8)}`,
+      name: data.name,
+      description: data.description,
+      price: data.price,
+      currency: data.currency || 'usd',
+      features: data.features || [],
+      active: true,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    };
+    
+    this.products.push(product);
+    this.saveProducts();
+    
+    return product;
+  }
+
+  updateProduct(id, updates) {
+    const index = this.products.findIndex(p => p.id === id || p.price_id === id);
+    if (index === -1) {
+      throw new Error('Product not found');
+    }
+    
+    this.products[index] = {
+      ...this.products[index],
+      ...updates,
+      updated_at: new Date().toISOString()
+    };
+    
+    this.saveProducts();
+    return this.products[index];
+  }
+
+  deleteProduct(id) {
+    const index = this.products.findIndex(p => p.id === id || p.price_id === id);
+    if (index === -1) {
+      throw new Error('Product not found');
+    }
+    
+    // Soft delete - just mark as inactive
+    this.products[index].active = false;
+    this.products[index].deleted_at = new Date().toISOString();
+    
+    this.saveProducts();
+    return { success: true };
+  }
+
+  // Order Management
+
+  saveOrders() {
+    fs.writeFileSync(this.ordersFile, JSON.stringify(this.orders, null, 2));
+  }
+
+  listOrders(filter = {}) {
+    let filtered = [...this.orders];
+    
+    if (filter.status) {
+      filtered = filtered.filter(o => o.status === filter.status);
+    }
+    
+    if (filter.customer_id) {
+      filtered = filtered.filter(o => o.customer_id === filter.customer_id);
+    }
+    
+    // Sort by created_at descending
+    filtered.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+    
+    return filtered;
+  }
+
+  createOrder(data) {
+    const order = {
+      id: `order_local_${uuidv4().substring(0, 8)}`,
+      customer_id: data.customer_id || `cus_local_${uuidv4().substring(0, 8)}`,
+      customer_email: data.customer_email,
+      product_id: data.product_id,
+      price_id: data.price_id,
+      amount: data.amount,
+      currency: data.currency || 'usd',
+      status: 'pending',
+      payment_intent_id: `pi_local_${uuidv4().substring(0, 8)}`,
+      metadata: data.metadata || {},
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    };
+    
+    this.orders.push(order);
+    this.saveOrders();
+    
+    return order;
+  }
+
+  updateOrderStatus(orderId, status) {
+    const order = this.orders.find(o => o.id === orderId);
+    if (!order) {
+      throw new Error('Order not found');
+    }
+    
+    order.status = status;
+    order.updated_at = new Date().toISOString();
+    
+    if (status === 'completed') {
+      order.completed_at = new Date().toISOString();
+    } else if (status === 'cancelled') {
+      order.cancelled_at = new Date().toISOString();
+    }
+    
+    this.saveOrders();
+    return order;
+  }
+
+  // Customer Management
+
+  saveCustomers() {
+    fs.writeFileSync(this.customersFile, JSON.stringify(this.customers, null, 2));
+  }
+
+  listCustomers() {
+    return this.customers;
+  }
+
+  createCustomer(data) {
+    const customer = {
+      id: `cus_local_${uuidv4().substring(0, 8)}`,
+      email: data.email,
+      name: data.name,
+      metadata: data.metadata || {},
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    };
+    
+    this.customers.push(customer);
+    this.saveCustomers();
+    
+    return customer;
+  }
+
+  // Analytics
+
+  getAnalytics() {
+    const now = new Date();
+    const thirtyDaysAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);
+    
+    const recentOrders = this.orders.filter(o => 
+      new Date(o.created_at) > thirtyDaysAgo
+    );
+    
+    const completedOrders = recentOrders.filter(o => o.status === 'completed');
+    const totalRevenue = completedOrders.reduce((sum, o) => sum + o.amount, 0);
+    
+    return {
+      total_orders: this.orders.length,
+      recent_orders: recentOrders.length,
+      completed_orders: completedOrders.length,
+      total_revenue: totalRevenue,
+      total_customers: this.customers.length,
+      total_products: this.products.filter(p => p.active).length,
+      revenue_by_product: this.getRevenueByProduct(),
+      orders_by_status: this.getOrdersByStatus(),
+      recent_activity: this.getRecentActivity()
+    };
+  }
+
+  getRevenueByProduct() {
+    const revenue = {};
+    
+    this.orders
+      .filter(o => o.status === 'completed')
+      .forEach(order => {
+        const product = this.getProduct(order.product_id);
+        if (product) {
+          if (!revenue[product.name]) {
+            revenue[product.name] = {
+              total: 0,
+              count: 0
+            };
+          }
+          revenue[product.name].total += order.amount;
+          revenue[product.name].count += 1;
+        }
+      });
+    
+    return revenue;
+  }
+
+  getOrdersByStatus() {
+    const statuses = {};
+    
+    this.orders.forEach(order => {
+      if (!statuses[order.status]) {
+        statuses[order.status] = 0;
+      }
+      statuses[order.status]++;
+    });
+    
+    return statuses;
+  }
+
+  getRecentActivity() {
+    const activities = [];
+    
+    // Add recent orders
+    this.orders.slice(-5).forEach(order => {
+      activities.push({
+        type: 'order',
+        message: `New order #${order.id.substring(12)} - $${order.amount / 100}`,
+        timestamp: order.created_at
+      });
+    });
+    
+    // Add recent customers
+    this.customers.slice(-3).forEach(customer => {
+      activities.push({
+        type: 'customer',
+        message: `New customer: ${customer.email}`,
+        timestamp: customer.created_at
+      });
+    });
+    
+    // Sort by timestamp
+    activities.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    
+    return activities.slice(0, 10);
+  }
+
+  // Export/Import for migration to production
+
+  exportData() {
+    return {
+      products: this.products,
+      orders: this.orders,
+      customers: this.customers,
+      exported_at: new Date().toISOString(),
+      version: '1.0.0'
+    };
+  }
+
+  importData(data) {
+    if (data.products) {
+      this.products = data.products;
+      this.saveProducts();
+    }
+    
+    if (data.orders) {
+      this.orders = data.orders;
+      this.saveOrders();
+    }
+    
+    if (data.customers) {
+      this.customers = data.customers;
+      this.saveCustomers();
+    }
+    
+    return {
+      success: true,
+      imported: {
+        products: data.products?.length || 0,
+        orders: data.orders?.length || 0,
+        customers: data.customers?.length || 0
+      }
+    };
+  }
+}
+
+module.exports = LocalAdminManager;

package/src/docs-html.js

@@ -402,6 +402,14 @@ NEXT_PUBLIC_SPAPS_API_URL=http://localhost:${port}</code></pre>
             <h3>🔄 Auto-Refresh</h3>
             <p>Tokens automatically refresh when expired</p>
           </div>
+          <div class="feature-card">
+            <h3>💳 Mock Stripe</h3>
+            <p>Checkout & webhooks work instantly - no Stripe account needed!</p>
+          </div>
+          <div class="feature-card">
+            <h3>⚡ Auto Webhooks</h3>
+            <p>Webhooks fire automatically 2 seconds after payment actions</p>
+          </div>
         </div>
       </section>
       
@@ -460,16 +468,55 @@ await spaps.refresh();</code></pre>
       <section id="payments">
         <h2>Payment Integration</h2>
         
-        <h3>Stripe Checkout</h3>
-        <pre><code>// Create checkout session
+        <div class="alert" style="background: #e0f2fe; border-color: #0369a1; margin-bottom: 2rem;">
+          <strong>🎉 New in v0.3.1:</strong> Local Stripe testing with automatic webhook simulation!
+          <br>• No Stripe account required for local development
+          <br>• Webhooks fire automatically after payments
+          <br>• Mock checkout page included
+          <br>• Test webhook UI at <code>/api/stripe/webhooks/test</code>
+        </div>
+        
+        <h3>Stripe Checkout (Works in Local Mode!)</h3>
+        <pre><code>// Create checkout session - works instantly in local mode!
 const session = await spaps.createCheckoutSession(
-  'price_123abc',                      // Stripe price ID
+  'price_local_validate',              // Use local price IDs
   'http://localhost:3000/success',     // Success URL
   'http://localhost:3000/cancel'       // Cancel URL (optional)
 );
 
-// Redirect to Stripe
-window.location.href = session.data.url;</code></pre>
+// In local mode: Returns mock checkout URL
+// In production: Returns real Stripe URL
+window.location.href = session.data.url;
+
+// Webhook fires automatically after 2 seconds in local mode!</code></pre>
+
+        <h3>Local Mode Test Products</h3>
+        <pre><code>// Pre-configured test products (Buildooor tiers)
+const prices = {
+  'price_local_validate': '$500 - Validate tier',
+  'price_local_prototype': '$2,500 - Prototype tier',
+  'price_local_strategy': '$10,000 - Strategy tier',
+  'price_local_build': '$25,000 - Build tier'
+};</code></pre>
+
+        <h3>Webhook Testing</h3>
+        <pre><code>// Your webhook handler (same code for local & production!)
+app.post('/webhook', (req, res) => {
+  const event = req.body;
+  
+  switch(event.type) {
+    case 'checkout.session.completed':
+      // In local: fires 2 seconds after checkout
+      // In production: fires when payment completes
+      console.log('Payment successful!');
+      break;
+  }
+  
+  res.json({ received: true });
+});
+
+// Test webhooks via UI (local only)
+// Visit: http://localhost:${port}/api/stripe/webhooks/test</code></pre>
         
         <h3>Subscription Management</h3>
         <pre><code>// Get current subscription

package/src/local-server.js

@@ -9,14 +9,21 @@ const express = require('express');
 const cors = require('cors');
 const chalk = require('chalk');
 const { generateDocsHTML } = require('./docs-html');
+const StripeLocalManager = require('./stripe-local');
+const LocalAdminManager = require('./admin-local');
 
 class LocalServer {
   constructor(options = {}) {
-    this.port = options.port || process.env.PORT || 3300;
+    this.port = options.port || process.env.PORT || 3456;
     this.json = options.json || false;
     this.app = express();
+    this.stripeManager = null;
+    this.adminManager = new LocalAdminManager();
     this.setupMiddleware();
     this.setupRoutes();
+    this.setupStripeRoutes();
+    this.setupAdminRoutes();
+    this.setupCatchAll();
   }
 
   setupMiddleware() {
@@ -170,7 +177,449 @@ class LocalServer {
     this.app.get('/docs', (req, res) => {
       res.send(generateDocsHTML(this.port));
     });
+  }
+
+  setupStripeRoutes() {
+    // Mock Stripe checkout session
+    this.app.post('/api/stripe/create-checkout-session', async (req, res) => {
+      const { price_id, success_url, cancel_url } = req.body;
+      const sessionId = 'cs_local_' + Date.now();
+      
+      res.json({
+        sessionId,
+        url: `http://localhost:${this.port}/checkout/${sessionId}?success=${encodeURIComponent(success_url)}&cancel=${encodeURIComponent(cancel_url)}`
+      });
+
+      // Simulate webhook after delay
+      setTimeout(async () => {
+        try {
+          await this.simulateCheckoutWebhook(sessionId, price_id);
+          if (!this.json) {
+            console.log(chalk.blue(`⚡ Webhook simulated: checkout.session.completed`));
+          }
+        } catch (error) {
+          console.error(chalk.red('Webhook simulation failed:'), error);
+        }
+      }, 2000);
+    });
+
+    // Mock checkout page
+    this.app.get('/checkout/:sessionId', (req, res) => {
+      const { sessionId } = req.params;
+      const { success, cancel } = req.query;
+      
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>SPAPS Local - Mock Checkout</title>
+          <style>
+            body { font-family: system-ui; max-width: 400px; margin: 100px auto; padding: 2rem; }
+            button { width: 100%; padding: 1rem; margin: 0.5rem 0; border: none; border-radius: 8px; cursor: pointer; font-size: 16px; }
+            .pay { background: #635bff; color: white; }
+            .pay:hover { background: #4b41e0; }
+            .cancel { background: #f5f5f5; }
+            .cancel:hover { background: #e5e5e5; }
+          </style>
+        </head>
+        <body>
+          <h1>🍠 Mock Checkout</h1>
+          <p>Session: ${sessionId}</p>
+          <p>This is a mock checkout page for local development.</p>
+          
+          <button class="pay" onclick="window.location='${success}'">
+            💳 Complete Payment
+          </button>
+          
+          <button class="cancel" onclick="window.location='${cancel}'">
+            Cancel
+          </button>
+          
+          <p style="margin-top: 2rem; color: #666; font-size: 14px;">
+            In production, this would be a real Stripe Checkout page.
+          </p>
+        </body>
+        </html>
+      `);
+    });
+
+    // Mock webhook endpoint
+    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}`));
+      }
+      
+      // Store for testing
+      this.lastWebhookEvent = event;
+      
+      res.json({ received: true });
+    });
+
+    // Webhook testing UI
+    this.app.get('/api/stripe/webhooks/test', (req, res) => {
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>SPAPS - Stripe Webhook Tester</title>
+          <style>
+            body { font-family: system-ui; max-width: 800px; margin: 0 auto; padding: 2rem; }
+            button { background: #635bff; color: white; border: none; padding: 0.75rem 1.5rem; border-radius: 6px; cursor: pointer; margin: 0.25rem; }
+            button:hover { background: #4b41e0; }
+            .event { background: #f9f9f9; padding: 1rem; margin: 1rem 0; border-radius: 8px; border-left: 4px solid #635bff; }
+          </style>
+        </head>
+        <body>
+          <h1>🍠 Stripe Webhook Tester</h1>
+          
+          <h2>Simulate Events</h2>
+          <div>
+            <button onclick="simulate('checkout.session.completed')">Checkout Completed</button>
+            <button onclick="simulate('payment_intent.succeeded')">Payment Success</button>
+            <button onclick="simulate('customer.subscription.created')">Subscription Created</button>
+          </div>
+          
+          <h2>Last Event</h2>
+          <div id="lastEvent">No events yet</div>
+          
+          <script>
+            async function simulate(type) {
+              const response = await fetch('/api/stripe/webhooks', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                  id: 'evt_local_' + Date.now(),
+                  type: type,
+                  data: { object: { id: type.split('.')[0] + '_' + Date.now() } }
+                })
+              });
+              
+              if (response.ok) {
+                document.getElementById('lastEvent').innerHTML = 
+                  '<div class="event">✅ ' + type + ' - ' + new Date().toLocaleTimeString() + '</div>';
+              }
+            }
+          </script>
+        </body>
+        </html>
+      `);
+    });
+  }
+
+  async simulateCheckoutWebhook(sessionId, priceId) {
+    const event = {
+      id: 'evt_local_' + Date.now(),
+      type: 'checkout.session.completed',
+      data: {
+        object: {
+          id: sessionId,
+          amount_total: this.getPriceAmount(priceId),
+          currency: 'usd',
+          customer: 'cus_local_' + Date.now(),
+          payment_status: 'paid',
+          status: 'complete',
+          metadata: { app_id: 'local-app-001', price_id: priceId }
+        }
+      }
+    };
+
+    // Send to webhook endpoint
+    const response = await fetch(`http://localhost:${this.port}/api/stripe/webhooks`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(event)
+    });
+
+    return response.ok;
+  }
+
+  getPriceAmount(priceId) {
+    const prices = {
+      'price_local_validate': 50000,
+      'price_local_prototype': 250000,
+      'price_local_strategy': 1000000,
+      'price_local_build': 2500000
+    };
+    return prices[priceId] || 10000;
+  }
+
+  setupAdminRoutes() {
+    // Admin API endpoints
+    
+    // List products
+    this.app.get('/api/admin/products', (req, res) => {
+      const products = this.adminManager.listProducts();
+      res.json({ success: true, data: products });
+    });
+
+    // Get single product
+    this.app.get('/api/admin/products/:id', (req, res) => {
+      try {
+        const product = this.adminManager.getProduct(req.params.id);
+        if (!product) {
+          return res.status(404).json({ success: false, error: 'Product not found' });
+        }
+        res.json({ success: true, data: product });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Create product
+    this.app.post('/api/admin/products', (req, res) => {
+      try {
+        const product = this.adminManager.createProduct(req.body);
+        res.json({ success: true, data: product });
+      } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+      }
+    });
+
+    // Update product
+    this.app.put('/api/admin/products/:id', (req, res) => {
+      try {
+        const product = this.adminManager.updateProduct(req.params.id, req.body);
+        res.json({ success: true, data: product });
+      } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+      }
+    });
+
+    // Delete product
+    this.app.delete('/api/admin/products/:id', (req, res) => {
+      try {
+        const result = this.adminManager.deleteProduct(req.params.id);
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+      }
+    });
+
+    // List orders
+    this.app.get('/api/admin/orders', (req, res) => {
+      const orders = this.adminManager.listOrders(req.query);
+      res.json({ success: true, data: orders });
+    });
+
+    // Create order (for testing)
+    this.app.post('/api/admin/orders', (req, res) => {
+      try {
+        const order = this.adminManager.createOrder(req.body);
+        res.json({ success: true, data: order });
+      } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+      }
+    });
+
+    // Update order status
+    this.app.patch('/api/admin/orders/:id/status', (req, res) => {
+      try {
+        const order = this.adminManager.updateOrderStatus(req.params.id, req.body.status);
+        res.json({ success: true, data: order });
+      } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+      }
+    });
+
+    // Analytics dashboard
+    this.app.get('/api/admin/analytics', (req, res) => {
+      const analytics = this.adminManager.getAnalytics();
+      res.json({ success: true, data: analytics });
+    });
+
+    // Export data (for migration to production)
+    this.app.get('/api/admin/export', (req, res) => {
+      const data = this.adminManager.exportData();
+      res.json({ success: true, data });
+    });
+
+    // Import data
+    this.app.post('/api/admin/import', (req, res) => {
+      try {
+        const result = this.adminManager.importData(req.body);
+        res.json({ success: true, data: result });
+      } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+      }
+    });
+
+    // Admin UI Dashboard
+    this.app.get('/admin', (req, res) => {
+      const analytics = this.adminManager.getAnalytics();
+      const products = this.adminManager.listProducts();
+      
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>SPAPS Admin - Local Mode</title>
+          <style>
+            * { margin: 0; padding: 0; box-sizing: border-box; }
+            body { font-family: system-ui; background: #f5f5f5; }
+            .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 2rem; }
+            .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
+            .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 1.5rem; margin: 2rem 0; }
+            .card { background: white; padding: 1.5rem; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+            .card h3 { margin-bottom: 1rem; color: #333; }
+            .stat { font-size: 2rem; font-weight: bold; color: #667eea; }
+            .label { color: #666; font-size: 0.9rem; }
+            table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
+            th, td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #eee; }
+            th { background: #f9f9f9; font-weight: 600; }
+            .btn { background: #667eea; color: white; border: none; padding: 0.5rem 1rem; border-radius: 4px; cursor: pointer; }
+            .btn:hover { background: #764ba2; }
+            .badge { padding: 0.25rem 0.5rem; border-radius: 4px; font-size: 0.85rem; }
+            .badge-success { background: #10b981; color: white; }
+            .badge-pending { background: #f59e0b; color: white; }
+            .nav { display: flex; gap: 2rem; margin-bottom: 2rem; }
+            .nav a { color: #667eea; text-decoration: none; font-weight: 500; }
+            .nav a:hover { text-decoration: underline; }
+          </style>
+        </head>
+        <body>
+          <div class="header">
+            <div class="container">
+              <h1>🍠 SPAPS Admin Dashboard</h1>
+              <p>Local Development Mode - Managing test data</p>
+            </div>
+          </div>
+          
+          <div class="container">
+            <div class="nav">
+              <a href="/admin">Dashboard</a>
+              <a href="/api/admin/products">Products API</a>
+              <a href="/api/admin/orders">Orders API</a>
+              <a href="/api/admin/export">Export Data</a>
+              <a href="/docs">Documentation</a>
+            </div>
+            
+            <div class="grid">
+              <div class="card">
+                <h3>Total Revenue</h3>
+                <div class="stat">$${(analytics.total_revenue / 100).toLocaleString()}</div>
+                <div class="label">From ${analytics.completed_orders} orders</div>
+              </div>
+              
+              <div class="card">
+                <h3>Active Products</h3>
+                <div class="stat">${analytics.total_products}</div>
+                <div class="label">Available for purchase</div>
+              </div>
+              
+              <div class="card">
+                <h3>Customers</h3>
+                <div class="stat">${analytics.total_customers}</div>
+                <div class="label">Total registered</div>
+              </div>
+              
+              <div class="card">
+                <h3>Recent Orders</h3>
+                <div class="stat">${analytics.recent_orders}</div>
+                <div class="label">Last 30 days</div>
+              </div>
+            </div>
+            
+            <div class="card">
+              <h3>Products</h3>
+              <table>
+                <thead>
+                  <tr>
+                    <th>Name</th>
+                    <th>Price</th>
+                    <th>Status</th>
+                    <th>Actions</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  ${products.map(p => `
+                    <tr>
+                      <td><strong>${p.name}</strong><br><small>${p.description}</small></td>
+                      <td>$${(p.price / 100).toLocaleString()}</td>
+                      <td><span class="badge badge-${p.active ? 'success' : 'pending'}">${p.active ? 'Active' : 'Inactive'}</span></td>
+                      <td>
+                        <button class="btn" onclick="editProduct('${p.id}')">Edit</button>
+                      </td>
+                    </tr>
+                  `).join('')}
+                </tbody>
+              </table>
+              
+              <div style="margin-top: 1rem;">
+                <button class="btn" onclick="addProduct()">+ Add Product</button>
+              </div>
+            </div>
+            
+            <div class="card" style="margin-top: 2rem;">
+              <h3>Recent Activity</h3>
+              <table>
+                <tbody>
+                  ${analytics.recent_activity.map(a => `
+                    <tr>
+                      <td>${a.message}</td>
+                      <td style="text-align: right; color: #999;">${new Date(a.timestamp).toLocaleString()}</td>
+                    </tr>
+                  `).join('')}
+                </tbody>
+              </table>
+            </div>
+            
+            <div class="card" style="margin-top: 2rem; background: #fef3c7;">
+              <h3>💡 Local Mode Notice</h3>
+              <p style="margin-top: 1rem;">
+                You're running in local development mode. All data is stored locally in <code>.spaps/</code> directory.
+              </p>
+              <p style="margin-top: 0.5rem;">
+                To migrate to production:
+              </p>
+              <ol style="margin: 1rem 0 0 2rem;">
+                <li>Export your data: <code>GET /api/admin/export</code></li>
+                <li>Set up Stripe products in production</li>
+                <li>Import customer data to production database</li>
+                <li>Update environment variables</li>
+              </ol>
+            </div>
+          </div>
+          
+          <script>
+            function editProduct(id) {
+              window.location.href = '/api/admin/products/' + id;
+            }
+            
+            function addProduct() {
+              const name = prompt('Product name:');
+              if (!name) return;
+              
+              const price = prompt('Price (in dollars):');
+              if (!price) return;
+              
+              fetch('/api/admin/products', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                  name,
+                  description: prompt('Description:') || '',
+                  price: Math.round(parseFloat(price) * 100)
+                })
+              })
+              .then(r => r.json())
+              .then(data => {
+                if (data.success) {
+                  alert('Product created!');
+                  location.reload();
+                }
+              });
+            }
+          </script>
+        </body>
+        </html>
+      `);
+    });
+  }
 
+  setupCatchAll() {
     // Catch-all for unimplemented routes
     this.app.use((req, res) => {
       res.status(404).json({

package/src/stripe-local.js

@@ -0,0 +1,263 @@
+/**
+ * Local Stripe Integration for SPAPS CLI
+ * Handles webhook forwarding and testing without Stripe CLI
+ */
+
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs');
+const path = require('path');
+
+class StripeLocalManager {
+  constructor(options = {}) {
+    this.port = options.port || 3300;
+    this.stripeCliProcess = null;
+    this.useBuiltInSimulator = options.simulator !== false;
+    this.webhookSecret = 'whsec_local_development_secret';
+  }
+
+  /**
+   * Check if Stripe CLI is installed
+   */
+  async checkStripeCLI() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('stripe --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Start Stripe webhook forwarding
+   */
+  async startWebhookForwarding() {
+    const hasStripeCLI = await this.checkStripeCLI();
+
+    if (hasStripeCLI && !this.useBuiltInSimulator) {
+      return this.startStripeCLI();
+    } else {
+      return this.startBuiltInSimulator();
+    }
+  }
+
+  /**
+   * Start Stripe CLI webhook forwarding
+   */
+  async startStripeCLI() {
+    console.log(chalk.blue('\n📡 Starting Stripe CLI webhook forwarding...'));
+
+    return new Promise((resolve, reject) => {
+      this.stripeCliProcess = spawn('stripe', [
+        'listen',
+        '--forward-to',
+        `localhost:${this.port}/api/stripe/webhooks`,
+        '--print-json'
+      ]);
+
+      let webhookSecret = null;
+
+      this.stripeCliProcess.stdout.on('data', (data) => {
+        const output = data.toString();
+        
+        // Parse webhook secret from output
+        if (!webhookSecret && output.includes('whsec_')) {
+          const match = output.match(/whsec_[a-zA-Z0-9]+/);
+          if (match) {
+            webhookSecret = match[0];
+            console.log(chalk.green(`✅ Stripe webhooks connected!`));
+            console.log(chalk.gray(`   Secret: ${webhookSecret}`));
+            console.log(chalk.gray(`   Forwarding to: http://localhost:${this.port}/api/stripe/webhooks`));
+            
+            // Save webhook secret to env file
+            this.saveWebhookSecret(webhookSecret);
+            
+            resolve({ 
+              type: 'stripe-cli',
+              secret: webhookSecret,
+              url: `http://localhost:${this.port}/api/stripe/webhooks`
+            });
+          }
+        }
+
+        // Log webhook events
+        try {
+          const json = JSON.parse(output);
+          if (json.type) {
+            console.log(chalk.blue(`⚡ Webhook: ${json.type}`));
+          }
+        } catch (e) {
+          // Not JSON, ignore
+        }
+      });
+
+      this.stripeCliProcess.stderr.on('data', (data) => {
+        const error = data.toString();
+        if (error.includes('login')) {
+          console.log(chalk.yellow('\n⚠️  Stripe CLI not logged in'));
+          console.log(chalk.cyan('   Run: stripe login'));
+          reject(new Error('Stripe CLI not authenticated'));
+        } else if (error.includes('Error')) {
+          console.error(chalk.red(`Stripe CLI error: ${error}`));
+        }
+      });
+
+      this.stripeCliProcess.on('close', (code) => {
+        if (code !== 0 && code !== null) {
+          reject(new Error(`Stripe CLI exited with code ${code}`));
+        }
+      });
+    });
+  }
+
+  /**
+   * Start built-in webhook simulator
+   */
+  async startBuiltInSimulator() {
+    console.log(chalk.blue('\n🎭 Starting built-in webhook simulator...'));
+    console.log(chalk.gray('   (Stripe CLI not found or simulator mode enabled)'));
+    
+    // The local server will handle webhook simulation
+    console.log(chalk.green(`✅ Webhook simulator ready!`));
+    console.log(chalk.gray(`   Test UI: http://localhost:${this.port}/api/stripe/webhooks/test`));
+    console.log(chalk.gray(`   Endpoint: http://localhost:${this.port}/api/stripe/webhooks`));
+    
+    return {
+      type: 'simulator',
+      secret: this.webhookSecret,
+      url: `http://localhost:${this.port}/api/stripe/webhooks`,
+      testUI: `http://localhost:${this.port}/api/stripe/webhooks/test`
+    };
+  }
+
+  /**
+   * Save webhook secret to local env file
+   */
+  saveWebhookSecret(secret) {
+    const envPath = path.join(process.cwd(), '.env.local');
+    
+    try {
+      let envContent = '';
+      if (fs.existsSync(envPath)) {
+        envContent = fs.readFileSync(envPath, 'utf8');
+      }
+
+      // Update or add webhook secret
+      if (envContent.includes('STRIPE_WEBHOOK_SECRET=')) {
+        envContent = envContent.replace(
+          /STRIPE_WEBHOOK_SECRET=.*/,
+          `STRIPE_WEBHOOK_SECRET=${secret}`
+        );
+      } else {
+        envContent += `\n# Auto-generated by SPAPS\nSTRIPE_WEBHOOK_SECRET=${secret}\n`;
+      }
+
+      fs.writeFileSync(envPath, envContent);
+      console.log(chalk.gray(`   Secret saved to .env.local`));
+    } catch (error) {
+      console.error(chalk.yellow(`   Could not save webhook secret: ${error.message}`));
+    }
+  }
+
+  /**
+   * Stop webhook forwarding
+   */
+  stop() {
+    if (this.stripeCliProcess) {
+      console.log(chalk.yellow('\n👋 Stopping Stripe webhook forwarding...'));
+      this.stripeCliProcess.kill();
+      this.stripeCliProcess = null;
+    }
+  }
+
+  /**
+   * Create test products for local development
+   */
+  async createTestProducts() {
+    console.log(chalk.blue('\n📦 Creating test Stripe products...'));
+
+    const products = [
+      {
+        id: 'prod_local_validate',
+        name: 'Validate Tier',
+        description: 'Landing page with data capture',
+        price: 50000, // $500
+        price_id: 'price_local_validate'
+      },
+      {
+        id: 'prod_local_prototype',
+        name: 'Prototype Tier',
+        description: 'Clickable prototype with core flows',
+        price: 250000, // $2,500
+        price_id: 'price_local_prototype'
+      },
+      {
+        id: 'prod_local_strategy',
+        name: 'Strategy Tier',
+        description: 'Technical architecture and roadmap',
+        price: 1000000, // $10,000
+        price_id: 'price_local_strategy'
+      },
+      {
+        id: 'prod_local_build',
+        name: 'Build Tier',
+        description: 'Full application development',
+        price: 2500000, // $25,000
+        price_id: 'price_local_build'
+      }
+    ];
+
+    // Store products in local config
+    const configPath = path.join(process.cwd(), '.spaps', 'stripe-products.json');
+    const configDir = path.dirname(configPath);
+
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(products, null, 2));
+    
+    console.log(chalk.green('✅ Test products created:'));
+    products.forEach(p => {
+      console.log(chalk.gray(`   - ${p.name}: $${p.price / 100}`));
+    });
+
+    return products;
+  }
+
+  /**
+   * Show webhook testing instructions
+   */
+  showInstructions() {
+    console.log(chalk.yellow('\n📚 Webhook Testing Guide:'));
+    console.log();
+    
+    if (this.useBuiltInSimulator) {
+      console.log('1. Open webhook tester UI:');
+      console.log(chalk.cyan(`   http://localhost:${this.port}/api/stripe/webhooks/test`));
+      console.log();
+      console.log('2. Or trigger via code:');
+      console.log(chalk.gray('   ```javascript'));
+      console.log(chalk.gray('   // Your app code'));
+      console.log(chalk.gray('   const result = await spaps.createCheckoutSession(...);'));
+      console.log(chalk.gray('   // Webhook fires automatically after 1 second'));
+      console.log(chalk.gray('   ```'));
+    } else {
+      console.log('1. Trigger test events:');
+      console.log(chalk.cyan('   stripe trigger payment_intent.succeeded'));
+      console.log();
+      console.log('2. Or use the Stripe Dashboard:');
+      console.log(chalk.cyan('   https://dashboard.stripe.com/test/webhooks'));
+    }
+    
+    console.log();
+    console.log(chalk.blue('💡 Tips:'));
+    console.log('   - Webhooks auto-retry on failure');
+    console.log('   - Check logs for webhook events');
+    console.log('   - Use webhook secret in your app');
+  }
+}
+
+module.exports = StripeLocalManager;