spaps 0.1.0 → 0.2.2

package/README.md

@@ -12,6 +12,8 @@ npx spaps local
 
 That's it! Your local SPAPS server is running at http://localhost:3300 🚀
 
+✨ **New in v0.2.0**: The `spaps local` command now starts a real server!
+
 ## Installation
 
 ```bash
@@ -28,10 +30,17 @@ Start a local SPAPS development server with:
 - Auto-authentication enabled
 - Test users (user/admin/premium)
 - CORS configured for any frontend
+- Mock Stripe endpoints
+- Full auth flow support
 
 ```bash
 spaps local
 # Server running at http://localhost:3300
+# Documentation at http://localhost:3300/docs
+
+# Options:
+spaps local --port 3301    # Use different port
+spaps local --open         # Open browser automatically
 ```
 
 ### `spaps init` 

package/bin/spaps.js

@@ -23,41 +23,116 @@ ${chalk.yellow('🍠 SPAPS')} - Sweet Potato Authentication & Payment Service
 program
   .name('spaps')
   .description('CLI for Sweet Potato Authentication & Payment Service')
-  .version(version);
+  .version(version)
+  .option('--json', 'Output in JSON format for machine parsing');
 
 // Local command - Start local development server
 program
   .command('local')
   .description('Start local SPAPS server (no API keys required!)')
   .option('-p, --port <port>', 'Port to run on', '3300')
-  .action((options) => {
-    console.log(logo);
-    console.log(chalk.green('🚀 Starting SPAPS local development server...'));
-    console.log(chalk.dim(`   Port: ${options.port}`));
-    console.log(chalk.dim('   Mode: Local Development (auto-auth enabled)'));
-    console.log();
+  .option('-o, --open', 'Open browser automatically', false)
+  .option('--json', 'Output in JSON format')
+  .action(async (options, command) => {
+    const isJson = options.json || command.parent.opts().json;
     
-    // For now, just show instructions
-    // TODO: Actually spawn the server process
-    console.log(chalk.yellow('📦 Local mode coming soon!'));
-    console.log();
-    console.log('For now, run SPAPS locally with:');
-    console.log(chalk.cyan('  git clone https://github.com/yourusername/sweet-potato'));
-    console.log(chalk.cyan('  cd sweet-potato'));
-    console.log(chalk.cyan('  npm install'));
-    console.log(chalk.cyan('  npm run dev'));
-    console.log();
-    console.log('Full CLI functionality coming in v0.2.0! 🚀');
+    if (!isJson) {
+      console.log(logo);
+    }
+    
+    try {
+      // Import and start the local server
+      const LocalServer = require('../src/local-server.js');
+      const server = new LocalServer({ port: options.port, json: isJson });
+      
+      if (isJson) {
+        // For JSON output, start server and return immediately
+        await server.start();
+        console.log(JSON.stringify({
+          success: true,
+          command: 'local',
+          server: {
+            url: `http://localhost:${options.port}`,
+            docs: `http://localhost:${options.port}/docs`,
+            mode: 'local-development',
+            port: parseInt(options.port),
+            features: {
+              autoAuth: true,
+              corsEnabled: true,
+              testUsers: ['user', 'admin', 'premium'],
+              apiKeyRequired: false
+            }
+          }
+        }));
+      } else {
+        await server.start();
+        
+        // Open browser if requested
+        if (options.open) {
+          const { exec } = require('child_process');
+          const url = `http://localhost:${options.port}/docs`;
+          const start = process.platform === 'darwin' ? 'open' :
+                       process.platform === 'win32' ? 'start' : 'xdg-open';
+          exec(`${start} ${url}`);
+        }
+      }
+      
+      // Keep process running
+      process.on('SIGINT', () => {
+        if (!isJson) {
+          console.log(chalk.yellow('\n👋 Shutting down SPAPS local server...'));
+        }
+        process.exit(0);
+      });
+      
+    } catch (error) {
+      if (isJson) {
+        console.log(JSON.stringify({
+          success: false,
+          command: 'local',
+          error: {
+            message: error.message,
+            code: error.code,
+            suggestion: error.code === 'EADDRINUSE' ? 
+              'Try a different port with --port option' : 
+              'Check error message for details'
+          }
+        }));
+      } else {
+        console.error(chalk.red('❌ Failed to start server:'), error.message);
+        
+        if (error.code === 'MODULE_NOT_FOUND') {
+          console.log(chalk.yellow('\n💡 Installing dependencies...'));
+          const { execSync } = require('child_process');
+          try {
+            execSync('npm install express cors', { 
+              cwd: path.join(__dirname, '..'),
+              stdio: 'inherit'
+            });
+            console.log(chalk.green('✅ Dependencies installed! Please run the command again.'));
+          } catch (installError) {
+            console.error(chalk.red('Failed to install dependencies. Please run: npm install express cors'));
+          }
+        }
+      }
+      
+      process.exit(1);
+    }
   });
 
 // Init command - Initialize SPAPS in existing project
 program
   .command('init')
   .description('Initialize SPAPS in your project')
-  .action(() => {
-    console.log(logo);
-    console.log(chalk.green('🔧 Initializing SPAPS...'));
-    console.log();
+  .option('--json', 'Output in JSON format')
+  .action((options, command) => {
+    const isJson = options.json || command.parent.opts().json;
+    
+    if (!isJson) {
+      console.log(logo);
+      console.log(chalk.green('🔧 Initializing SPAPS...'));
+      console.log();
+    }
     
     // Create minimal .env.local
     const envContent = `# SPAPS Local Development Configuration
@@ -70,20 +145,43 @@ NODE_ENV=development
 # SPAPS_API_KEY=your-api-key-here
 `;
 
+    const result = {
+      success: true,
+      command: 'init',
+      files_created: [],
+      files_skipped: [],
+      next_steps: [
+        'npx spaps local',
+        'npm install @spaps/sdk',
+        'Start coding!'
+      ]
+    };
+
     if (!fs.existsSync('.env.local')) {
       fs.writeFileSync('.env.local', envContent);
-      console.log(chalk.green('✅ Created .env.local'));
+      result.files_created.push('.env.local');
+      if (!isJson) {
+        console.log(chalk.green('✅ Created .env.local'));
+      }
     } else {
-      console.log(chalk.yellow('⚠️  .env.local already exists'));
+      result.files_skipped.push('.env.local');
+      result.message = '.env.local already exists';
+      if (!isJson) {
+        console.log(chalk.yellow('⚠️  .env.local already exists'));
+      }
     }
     
-    console.log();
-    console.log(chalk.green('✨ SPAPS initialized!'));
-    console.log();
-    console.log('Next steps:');
-    console.log(chalk.cyan('  1. Run: npx spaps local'));
-    console.log(chalk.cyan('  2. Install SDK: npm install @spaps/sdk'));
-    console.log(chalk.cyan('  3. Start coding!'));
+    if (isJson) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log();
+      console.log(chalk.green('✨ SPAPS initialized!'));
+      console.log();
+      console.log('Next steps:');
+      console.log(chalk.cyan('  1. Run: npx spaps local'));
+      console.log(chalk.cyan('  2. Install SDK: npm install @spaps/sdk'));
+      console.log(chalk.cyan('  3. Start coding!'));
+    }
   });
 
 // Create command (placeholder)

package/client.js

@@ -0,0 +1,102 @@
+/**
+ * SPAPS Client - Re-export from spaps-sdk
+ * This allows users to import from 'spaps/client'
+ */
+
+try {
+  // Try to load spaps-sdk if it's installed
+  module.exports = require('spaps-sdk');
+} catch (error) {
+  // Fallback to a simple client implementation for local development
+  const axios = require('axios');
+  
+  class SPAPSClient {
+    constructor(config = {}) {
+      const apiUrl = config.apiUrl || process.env.SPAPS_API_URL || 'http://localhost:3300';
+      this.isLocalMode = apiUrl.includes('localhost') || apiUrl.includes('127.0.0.1');
+      
+      this.client = axios.create({
+        baseURL: apiUrl,
+        timeout: config.timeout || 10000,
+        headers: {
+          'Content-Type': 'application/json',
+          ...(config.apiKey && { 'X-API-Key': config.apiKey })
+        }
+      });
+      
+      this.accessToken = null;
+      this.refreshToken = null;
+    }
+    
+    async login(email, password) {
+      const response = await this.client.post('/api/auth/login', { email, password });
+      this.accessToken = response.data.access_token;
+      this.refreshToken = response.data.refresh_token;
+      return response;
+    }
+    
+    async register(email, password) {
+      const response = await this.client.post('/api/auth/register', { email, password });
+      this.accessToken = response.data.access_token;
+      this.refreshToken = response.data.refresh_token;
+      return response;
+    }
+    
+    async walletSignIn(walletAddress, signature, message, chainType = 'solana') {
+      const response = await this.client.post('/api/auth/wallet-sign-in', {
+        wallet_address: walletAddress,
+        signature,
+        message,
+        chain_type: chainType
+      });
+      this.accessToken = response.data.access_token;
+      this.refreshToken = response.data.refresh_token;
+      return response;
+    }
+    
+    async getUser() {
+      return this.client.get('/api/auth/user', {
+        headers: { Authorization: `Bearer ${this.accessToken}` }
+      });
+    }
+    
+    async createCheckoutSession(priceId, successUrl, cancelUrl) {
+      return this.client.post('/api/stripe/create-checkout-session', 
+        { price_id: priceId, success_url: successUrl, cancel_url: cancelUrl },
+        { headers: { Authorization: `Bearer ${this.accessToken}` } }
+      );
+    }
+    
+    async getSubscription() {
+      return this.client.get('/api/stripe/subscription', {
+        headers: { Authorization: `Bearer ${this.accessToken}` }
+      });
+    }
+    
+    async getUsageBalance() {
+      return this.client.get('/api/usage/balance', {
+        headers: { Authorization: `Bearer ${this.accessToken}` }
+      });
+    }
+    
+    isAuthenticated() {
+      return !!this.accessToken;
+    }
+    
+    getAccessToken() {
+      return this.accessToken;
+    }
+    
+    setAccessToken(token) {
+      this.accessToken = token;
+    }
+    
+    isLocalMode() {
+      return this.isLocalMode;
+    }
+  }
+  
+  module.exports = SPAPSClient;
+  module.exports.SPAPSClient = SPAPSClient;
+  module.exports.default = SPAPSClient;
+}

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "spaps",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "Sweet Potato Authentication & Payment Service CLI - Zero-config local development and project scaffolding",
   "main": "bin/spaps.js",
   "bin": {
     "spaps": "./bin/spaps.js"
   },
+  "exports": {
+    ".": "./bin/spaps.js",
+    "./client": "./client.js"
+  },
   "scripts": {
     "test": "echo \"No tests yet\""
   },
@@ -37,13 +41,17 @@
     "commander": "^11.1.0",
     "ora": "^5.4.1",
     "prompts": "^2.4.2",
-    "axios": "^1.6.0"
+    "axios": "^1.6.0",
+    "express": "^4.18.2",
+    "cors": "^2.8.5"
   },
   "engines": {
     "node": ">=16.0.0"
   },
   "files": [
     "bin",
+    "src",
+    "client.js",
     "README.md"
   ]
 }

package/src/local-server.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+/**
+ * SPAPS Local Development Server
+ * Minimal, zero-config server for local development
+ */
+
+const express = require('express');
+const cors = require('cors');
+const chalk = require('chalk');
+
+class LocalServer {
+  constructor(options = {}) {
+    this.port = options.port || process.env.PORT || 3300;
+    this.json = options.json || false;
+    this.app = express();
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  setupMiddleware() {
+    // CORS - allow everything in local mode
+    this.app.use(cors({
+      origin: true,
+      credentials: true,
+      methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+      allowedHeaders: ['Content-Type', 'Authorization', 'X-API-Key', 'X-Test-User'],
+    }));
+
+    // Body parsing
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+
+    // Local mode indicator
+    this.app.use((req, res, next) => {
+      res.setHeader('X-SPAPS-Mode', 'local-development');
+      
+      // Auto-auth in local mode
+      if (!req.headers.authorization && !req.headers['x-api-key']) {
+        req.headers['x-api-key'] = 'local-dev-key';
+        req.user = {
+          id: 'local-user-123',
+          email: 'dev@localhost',
+          role: req.query._user || req.headers['x-test-user'] || 'user'
+        };
+      }
+      
+      // Log requests (unless in JSON mode)
+      if (!this.json) {
+        console.log(chalk.dim(`${req.method} ${req.path}`));
+      }
+      next();
+    });
+  }
+
+  setupRoutes() {
+    // Health check
+    this.app.get('/health', (req, res) => {
+      res.json({ 
+        status: 'healthy',
+        mode: 'local-development',
+        version: '0.2.0',
+        timestamp: new Date().toISOString()
+      });
+    });
+
+    // Local mode status
+    this.app.get('/health/local-mode', (req, res) => {
+      res.json({
+        enabled: true,
+        environment: 'local-development',
+        features: {
+          autoAuth: true,
+          corsEnabled: true,
+          testUsers: ['user', 'admin', 'premium'],
+          apiKeyRequired: false
+        }
+      });
+    });
+
+    // Mock authentication endpoints
+    this.app.post('/api/auth/login', (req, res) => {
+      const { email, password } = req.body;
+      res.json({
+        access_token: 'local-jwt-token-' + Date.now(),
+        refresh_token: 'local-refresh-token-' + Date.now(),
+        user: {
+          id: 'local-user-123',
+          email: email || 'dev@localhost',
+          role: 'user'
+        }
+      });
+    });
+
+    this.app.post('/api/auth/register', (req, res) => {
+      const { email, password } = req.body;
+      res.json({
+        access_token: 'local-jwt-token-' + Date.now(),
+        refresh_token: 'local-refresh-token-' + Date.now(),
+        user: {
+          id: 'local-user-' + Date.now(),
+          email: email || 'dev@localhost',
+          role: 'user'
+        }
+      });
+    });
+
+    this.app.post('/api/auth/wallet-sign-in', (req, res) => {
+      const { wallet_address, chain_type } = req.body;
+      res.json({
+        access_token: 'local-jwt-token-' + Date.now(),
+        refresh_token: 'local-refresh-token-' + Date.now(),
+        user: {
+          id: 'local-wallet-user-123',
+          wallet_address,
+          chain_type,
+          role: 'user'
+        }
+      });
+    });
+
+    this.app.post('/api/auth/refresh', (req, res) => {
+      res.json({
+        access_token: 'local-jwt-token-refreshed-' + Date.now(),
+        refresh_token: 'local-refresh-token-refreshed-' + Date.now()
+      });
+    });
+
+    this.app.post('/api/auth/logout', (req, res) => {
+      res.json({ success: true, message: 'Logged out successfully' });
+    });
+
+    this.app.get('/api/auth/user', (req, res) => {
+      res.json({
+        id: req.user?.id || 'local-user-123',
+        email: req.user?.email || 'dev@localhost',
+        role: req.user?.role || 'user',
+        created_at: new Date().toISOString()
+      });
+    });
+
+    // Mock Stripe endpoints
+    this.app.post('/api/stripe/create-checkout-session', (req, res) => {
+      res.json({
+        sessionId: 'cs_test_local_' + Date.now(),
+        url: 'https://checkout.stripe.com/pay/cs_test_local'
+      });
+    });
+
+    this.app.get('/api/stripe/subscription', (req, res) => {
+      res.json({
+        id: 'sub_local_123',
+        status: 'active',
+        plan: 'premium',
+        current_period_end: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString()
+      });
+    });
+
+    // Mock usage endpoints
+    this.app.get('/api/usage/balance', (req, res) => {
+      res.json({
+        balance: 1000,
+        currency: 'credits',
+        updated_at: new Date().toISOString()
+      });
+    });
+
+    // Documentation endpoint
+    this.app.get('/docs', (req, res) => {
+      res.send(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>SPAPS Local Mode</title>
+          <style>
+            body { 
+              font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+              max-width: 800px;
+              margin: 50px auto;
+              padding: 20px;
+              line-height: 1.6;
+            }
+            h1 { color: #ff6b6b; }
+            code { 
+              background: #f4f4f4;
+              padding: 2px 6px;
+              border-radius: 3px;
+            }
+            pre {
+              background: #f4f4f4;
+              padding: 15px;
+              border-radius: 5px;
+              overflow-x: auto;
+            }
+            .endpoint {
+              margin: 20px 0;
+              padding: 15px;
+              border-left: 3px solid #ff6b6b;
+              background: #fff9f9;
+            }
+          </style>
+        </head>
+        <body>
+          <h1>🍠 SPAPS Local Development Mode</h1>
+          <p>You're running in <strong>local development mode</strong>. No API keys required!</p>
+          
+          <h2>Quick Start</h2>
+          <pre>
+// No configuration needed!
+const response = await fetch('http://localhost:${this.port}/api/auth/login', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ 
+    email: 'test@example.com',
+    password: 'password' 
+  })
+});
+const { access_token, user } = await response.json();
+          </pre>
+
+          <h2>Available Endpoints</h2>
+          
+          <div class="endpoint">
+            <strong>GET /health</strong> - Health check
+          </div>
+          
+          <div class="endpoint">
+            <strong>POST /api/auth/login</strong> - Email/password login
+          </div>
+          
+          <div class="endpoint">
+            <strong>POST /api/auth/register</strong> - Create account
+          </div>
+          
+          <div class="endpoint">
+            <strong>POST /api/auth/wallet-sign-in</strong> - Wallet authentication
+          </div>
+          
+          <div class="endpoint">
+            <strong>GET /api/auth/user</strong> - Get current user
+          </div>
+          
+          <div class="endpoint">
+            <strong>POST /api/stripe/create-checkout-session</strong> - Create payment session
+          </div>
+          
+          <div class="endpoint">
+            <strong>GET /api/usage/balance</strong> - Check usage balance
+          </div>
+
+          <h2>Test Users</h2>
+          <p>Switch between test users by adding <code>?_user=admin</code> or <code>?_user=premium</code> to any request.</p>
+          
+          <h2>Environment</h2>
+          <pre>
+Mode: ${process.env.NODE_ENV || 'development'}
+Port: ${this.port}
+Auto-Auth: Enabled
+CORS: Enabled (all origins)
+          </pre>
+        </body>
+        </html>
+      `);
+    });
+
+    // Catch-all for unimplemented routes
+    this.app.use((req, res) => {
+      res.status(404).json({
+        error: 'Not found',
+        message: `Endpoint ${req.method} ${req.path} not implemented in local mode`,
+        suggestion: 'Check /docs for available endpoints'
+      });
+    });
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      const server = this.app.listen(this.port, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          if (!this.json) {
+            console.log();
+            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`));
+            console.log(chalk.dim('   Press Ctrl+C to stop'));
+            console.log();
+          }
+          resolve(server);
+        }
+      });
+
+      // Handle errors
+      server.on('error', (err) => {
+        if (!this.json) {
+          if (err.code === 'EADDRINUSE') {
+            console.error(chalk.red(`❌ Port ${this.port} is already in use`));
+            console.log(chalk.yellow('💡 Try: spaps local --port 3301'));
+          } else {
+            console.error(chalk.red('❌ Server error:'), err.message);
+          }
+        }
+        reject(err);
+      });
+    });
+  }
+}
+
+// Export for use in CLI
+module.exports = LocalServer;
+
+// Run directly if called as script
+if (require.main === module) {
+  const server = new LocalServer();
+  server.start().catch(console.error);
+  
+  // Graceful shutdown
+  process.on('SIGINT', () => {
+    console.log(chalk.yellow('\n👋 Shutting down...'));
+    process.exit(0);
+  });
+}