spaps 0.5.0 → 0.5.2

package/src/docs-system.js

@@ -16,21 +16,21 @@ ${chalk.green('Installation:')}
   yarn add spaps-sdk
 
 ${chalk.green('Basic Usage:')}
-  ${chalk.gray('// ES6 Import')}
-  import { SPAPSClient } from 'spaps-sdk'
+  ${chalk.gray('// ES Module')}
+  import { SweetPotatoSDK } from 'spaps-sdk'
   
   ${chalk.gray('// CommonJS')}
-  const { SPAPSClient } = require('spaps-sdk')
+  const { SweetPotatoSDK } = require('spaps-sdk')
   
   ${chalk.gray('// Create client (auto-detects local mode)')}
-  const spaps = new SPAPSClient()
-  
-  ${chalk.gray('// With custom config')}
-  const spaps = new SPAPSClient({
-    apiUrl: 'http://localhost:3300',
-    apiKey: 'your-api-key',  ${chalk.gray('// Not needed for localhost')}
-    timeout: 10000
+  const sdk = new SweetPotatoSDK({
+    apiUrl: process.env.SPAPS_API_URL || 'http://localhost:3300',
+    apiKey: process.env.SPAPS_API_KEY,  ${chalk.gray('// Not required in local mode')}
   })
+  
+  ${chalk.gray('// Sign in with email/password (local mode accepts any credentials)')}
+  const auth = await sdk.auth.signInWithPassword({ email: 'user@example.com', password: 'password' })
+  console.log('User:', auth.user)
 `
   },
 
@@ -39,48 +39,30 @@ ${chalk.green('Basic Usage:')}
     content: `
 ${chalk.green('Email/Password Authentication:')}
   ${chalk.gray('// Register new user')}
-  const { data } = await spaps.register(email, password)
-  console.log('User:', data.user)
-  console.log('Token:', data.access_token)
+  const registered = await sdk.auth.register({ email, password })
+  console.log('User:', registered.user)
+  console.log('Token:', registered.access_token)
   
   ${chalk.gray('// Login existing user')}
-  const { data } = await spaps.login(email, password)
+  const auth = await sdk.auth.signInWithPassword({ email, password })
   
   ${chalk.gray('// Check authentication status')}
-  if (spaps.isAuthenticated()) {
-    const user = await spaps.getUser()
-    console.log('Current user:', user.data)
+  if (sdk.auth.isAuthenticated()) {
+    const user = await sdk.auth.getCurrentUser()
+    console.log('Current user:', user)
   }
   
   ${chalk.gray('// Logout')}
-  await spaps.logout()
+  await sdk.auth.logout()
 
 ${chalk.green('Wallet Authentication:')}
-  ${chalk.gray('// Solana wallet')}
-  await spaps.walletSignIn(
-    walletAddress,
-    signature,
-    message,
-    'solana'
-  )
-  
-  ${chalk.gray('// Ethereum wallet')}
-  await spaps.walletSignIn(
-    walletAddress,
-    signature,
-    message,
-    'ethereum'
-  )
+  ${chalk.gray('// One-call helper: authenticateWallet')}
+  const resp = await sdk.auth.authenticateWallet(walletAddress, signMessage, 'ethereum')
+  console.log('User:', resp.user)
 
 ${chalk.green('Token Management:')}
-  ${chalk.gray('// Get current token')}
-  const token = spaps.getAccessToken()
-  
-  ${chalk.gray('// Set token manually')}
-  spaps.setAccessToken(token)
-  
-  ${chalk.gray('// Refresh token')}
-  await spaps.refresh()
+  ${chalk.gray('// Access token is managed internally; you can also set it manually')}
+  sdk.setAccessToken('jwt-token')
 `
   },
 
@@ -89,33 +71,25 @@ ${chalk.green('Token Management:')}
     content: `
 ${chalk.green('Stripe Checkout:')}
   ${chalk.gray('// Create checkout session')}
-  const session = await spaps.createCheckoutSession(
-    'price_123abc',           ${chalk.gray('// Stripe price ID')}
-    'http://localhost:3000/success',  ${chalk.gray('// Success URL')}
-    'http://localhost:3000/cancel'    ${chalk.gray('// Cancel URL (optional)')}
-  )
+  const session = await sdk.payments.createCheckoutSession({
+    price_id: 'price_123abc',
+    success_url: 'http://localhost:3000/success',
+    cancel_url: 'http://localhost:3000/cancel'
+  })
   
   ${chalk.gray('// Redirect to Stripe')}
-  window.location.href = session.data.url
+  window.location.href = session.url
 
 ${chalk.green('Subscription Management:')}
   ${chalk.gray('// Get current subscription')}
-  const subscription = await spaps.getSubscription()
-  console.log('Status:', subscription.data.status)
-  console.log('Plan:', subscription.data.plan)
-  console.log('Renews:', subscription.data.current_period_end)
+  // Example subscription helpers would go here if enabled
   
   ${chalk.gray('// Cancel subscription')}
   await spaps.cancelSubscription()
 
 ${chalk.green('Usage Tracking:')}
   ${chalk.gray('// Check balance')}
-  const balance = await spaps.getUsageBalance()
-  console.log('Credits:', balance.data.balance)
-  
-  ${chalk.gray('// Record usage')}
-  await spaps.recordUsage('api-call', 1)
-  await spaps.recordUsage('image-generation', 10)
+  // Usage APIs depend on your server config
 `
   },
 
@@ -132,18 +106,9 @@ ${chalk.green('Environment Variables:')}
   NEXT_PUBLIC_SPAPS_API_KEY=spaps_live_abc123...
 
 ${chalk.green('Configuration Options:')}
-  const spaps = new SPAPSClient({
-    ${chalk.gray('// API endpoint (auto-detected from env)')}
-    apiUrl: 'http://localhost:3300',
-    
-    ${chalk.gray('// API key (not needed for localhost)')}
-    apiKey: 'spaps_live_abc123...',
-    
-    ${chalk.gray('// Request timeout in milliseconds')}
-    timeout: 10000,
-    
-    ${chalk.gray('// Auto-detect local mode (default: true)')}
-    autoDetect: true
+  const sdk = new SweetPotatoSDK({
+    apiUrl: process.env.SPAPS_API_URL || 'http://localhost:3300',
+    apiKey: process.env.SPAPS_API_KEY, ${chalk.gray('// Omit in local dev')}
   })
 
 ${chalk.green('Local Mode Detection:')}
@@ -153,7 +118,7 @@ ${chalk.green('Local Mode Detection:')}
   - No API URL is provided
   
   ${chalk.gray('// Check if in local mode')}
-  if (spaps.isLocalMode()) {
+  if (sdk.isLocalMode) {
     console.log('Running in local mode - no API key needed!')
   }
 `
@@ -165,14 +130,14 @@ ${chalk.green('Local Mode Detection:')}
 ${chalk.green('React Context Setup:')}
   ${chalk.gray('// contexts/SpapsContext.tsx')}
   import { createContext, useContext } from 'react'
-  import { SPAPSClient } from 'spaps-sdk'
+  import { SweetPotatoSDK } from 'spaps-sdk'
   
-  const spaps = new SPAPSClient()
-  const SpapsContext = createContext(spaps)
+  const sdk = new SweetPotatoSDK({ apiUrl: process.env.NEXT_PUBLIC_SPAPS_API_URL || 'http://localhost:3300' })
+  const SpapsContext = createContext(sdk)
   
   export function SpapsProvider({ children }) {
     return (
-      <SpapsContext.Provider value={spaps}>
+      <SpapsContext.Provider value={sdk}>
         {children}
       </SpapsContext.Provider>
     )
@@ -273,26 +238,23 @@ ${chalk.green('Server Actions:')}
   ${chalk.gray('// app/actions/auth.ts')}
   'use server'
   
-  import { SPAPSClient } from 'spaps-sdk'
+  import { SweetPotatoSDK } from 'spaps-sdk'
   import { cookies } from 'next/headers'
   
-  const spaps = new SPAPSClient({
-    apiUrl: process.env.SPAPS_API_URL,
-    apiKey: process.env.SPAPS_API_KEY
-  })
+  const sdk = new SweetPotatoSDK({ apiUrl: process.env.SPAPS_API_URL, apiKey: process.env.SPAPS_API_KEY })
   
   export async function loginAction(email: string, password: string) {
-    const { data } = await spaps.login(email, password)
+    const auth = await sdk.auth.signInWithPassword({ email, password })
     
     // Store token in cookie
-    cookies().set('spaps_token', data.access_token, {
+    cookies().set('spaps_token', auth.access_token, {
       httpOnly: true,
       secure: process.env.NODE_ENV === 'production',
       sameSite: 'lax',
       maxAge: 60 * 60 * 24 * 7 // 1 week
     })
     
-    return { success: true, user: data.user }
+    return { success: true, user: auth.user }
   }
 
 ${chalk.green('Middleware Protection:')}
@@ -322,17 +284,14 @@ ${chalk.green('Middleware Protection:')}
 ${chalk.green('Express Middleware:')}
   ${chalk.gray('// server.js')}
   const express = require('express')
-  const { SPAPSClient } = require('spaps-sdk')
+  const { SweetPotatoSDK } = require('spaps-sdk')
   
   const app = express()
-  const spaps = new SPAPSClient({
-    apiUrl: process.env.SPAPS_API_URL,
-    apiKey: process.env.SPAPS_API_KEY
-  })
+  const sdk = new SweetPotatoSDK({ apiUrl: process.env.SPAPS_API_URL, apiKey: process.env.SPAPS_API_KEY })
   
   ${chalk.gray('// Add SPAPS to request')}
   app.use((req, res, next) => {
-    req.spaps = spaps
+    req.spaps = sdk
     next()
   })
   
@@ -346,8 +305,8 @@ ${chalk.green('Express Middleware:')}
     
     try {
       req.spaps.setAccessToken(token)
-      const { data } = await req.spaps.getUser()
-      req.user = data
+      const user = await req.spaps.auth.getCurrentUser()
+      req.user = user
       next()
     } catch (error) {
       res.status(401).json({ error: 'Invalid token' })
@@ -360,8 +319,8 @@ ${chalk.green('Route Examples:')}
     const { email, password } = req.body
     
     try {
-      const { data } = await req.spaps.login(email, password)
-      res.json(data)
+      const auth = await req.spaps.auth.signInWithPassword({ email, password })
+      res.json(auth)
     } catch (error) {
       res.status(401).json({ error: 'Invalid credentials' })
     }
@@ -567,17 +526,17 @@ ${chalk.green('E2E Testing with Cypress:')}
 ${chalk.green('Mocking for Tests:')}
   ${chalk.gray('// Mock SPAPS client')}
   jest.mock('spaps-sdk', () => ({
-    SPAPSClient: jest.fn().mockImplementation(() => ({
-      login: jest.fn().mockResolvedValue({
-        data: {
+    SweetPotatoSDK: jest.fn().mockImplementation(() => ({
+      auth: {
+        signInWithPassword: jest.fn().mockResolvedValue({
           user: { id: '123', email: 'test@example.com' },
-          access_token: 'mock-token'
-        }
-      }),
-      isAuthenticated: jest.fn().mockReturnValue(true),
-      getUser: jest.fn().mockResolvedValue({
-        data: { id: '123', email: 'test@example.com' }
-      })
+          access_token: 'mock-token',
+          refresh_token: 'mock-refresh'
+        }),
+        isAuthenticated: jest.fn().mockReturnValue(true),
+        getCurrentUser: jest.fn().mockResolvedValue({ id: '123', email: 'test@example.com' })
+      },
+      setAccessToken: jest.fn()
     }))
   }))
 `
@@ -587,39 +546,29 @@ ${chalk.green('Mocking for Tests:')}
     title: 'API Reference',
     content: `
 ${chalk.green('Authentication Methods:')}
-  login(email: string, password: string): Promise<{data: AuthResponse}>
-  register(email: string, password: string): Promise<{data: AuthResponse}>
-  walletSignIn(address: string, signature: string, message: string, chain: string): Promise<{data: AuthResponse}>
-  refresh(refreshToken?: string): Promise<{data: AuthResponse}>
-  logout(): Promise<void>
-  getUser(): Promise<{data: User}>
+  sdk.auth.signInWithPassword({ email, password }): Promise<AuthResponse>
+  sdk.auth.register({ email, password, username? }): Promise<AuthResponse>
+  sdk.auth.authenticateWallet(address, signFn, chain?): Promise<AuthResponse>
+  sdk.auth.refreshToken(refreshToken): Promise<AuthResponse>
+  sdk.auth.logout(): Promise<void>
+  sdk.auth.getCurrentUser(): Promise<User>
 
 ${chalk.green('Payment Methods:')}
-  createCheckoutSession(priceId: string, successUrl: string, cancelUrl?: string): Promise<{data: CheckoutSession}>
-  getSubscription(): Promise<{data: Subscription}>
-  cancelSubscription(): Promise<void>
+  sdk.payments.createCheckoutSession({ price_id, success_url, cancel_url }): Promise<CheckoutSession>
+  sdk.payments.getCheckoutSession(id): Promise<CheckoutSession>
+  sdk.payments.listProducts({ category?, active?, limit? }): Promise<ProductsListResponse>
 
 ${chalk.green('Usage Methods:')}
-  getUsageBalance(): Promise<{data: UsageBalance}>
-  recordUsage(feature: string, amount: number): Promise<void>
+  See server docs if enabled
 
 ${chalk.green('Utility Methods:')}
-  isAuthenticated(): boolean
-  getAccessToken(): string | undefined
-  setAccessToken(token: string): void
-  isLocalMode(): boolean
-  health(): Promise<{data: any}>
-
-${chalk.green('Properties:')}
-  client: AxiosInstance  ${chalk.gray('// Direct access to Axios client')}
+  sdk.setAccessToken(token: string): void
+  sdk.clearAccessToken(): void
 
 ${chalk.green('Response Types:')}
-  ${chalk.gray('// All methods return data wrapped in { data: T }')}
-  ${chalk.gray('// This matches Axios response structure')}
-  ${chalk.gray('// Example:')}
-  const response = await spaps.login(email, password)
-  // response.data contains AuthResponse
-  // response.status, response.headers also available
+  ${chalk.gray('// Methods generally return typed objects directly')}
+  const auth = await sdk.auth.signInWithPassword({ email, password })
+  console.log(auth.access_token)
 `
   }
 };
@@ -636,7 +585,7 @@ ${chalk.green('Authentication Endpoints:')}
   GET    /api/auth/user             ${chalk.gray('Get current user')}
 
 ${chalk.green('Stripe Endpoints:')}
-  POST   /api/stripe/create-checkout-session  ${chalk.gray('Create Stripe checkout')}
+  POST   /api/stripe/checkout-sessions       ${chalk.gray('Create Stripe checkout')}
   GET    /api/stripe/subscription             ${chalk.gray('Get subscription status')}
   DELETE /api/stripe/subscription             ${chalk.gray('Cancel subscription')}
   POST   /api/stripe/webhook                  ${chalk.gray('Stripe webhook handler')}
@@ -803,4 +752,4 @@ module.exports = {
   searchDocs,
   SDK_DOCS,
   API_ENDPOINTS
-};
+};

package/src/doctor.js

@@ -0,0 +1,217 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const net = require('net');
+const chalk = require('chalk');
+
+const { getServerStatus } = require('./ai-helper');
+const { DEFAULT_PORT } = require('./config');
+
+function checkNodeVersion() {
+  const version = process.versions.node || '0.0.0';
+  const major = parseInt(version.split('.')[0], 10) || 0;
+  const ok = major >= 16;
+  return {
+    check: 'node_version',
+    success: ok,
+    details: { version, requirement: '>=16' },
+    fix: ok ? null : 'Upgrade Node.js to v18+ (recommended)'
+  };
+}
+
+async function checkPort(port) {
+  // If server is running, we consider port check OK
+  const status = await getServerStatus(port);
+  if (status.running) {
+    return {
+      check: 'port',
+      success: true,
+      details: { port, running: true, url: status.url },
+      fix: null
+    };
+  }
+  // Otherwise ensure port is free to bind
+  const free = await new Promise((resolve) => {
+    const tester = net.createServer()
+      .once('error', () => resolve(false))
+      .once('listening', () => tester.once('close', () => resolve(true)).close())
+      .listen(port, '127.0.0.1');
+  });
+  return {
+    check: 'port',
+    success: free,
+    details: { port, running: false, free },
+    fix: free ? null : `Use a different port: npx spaps local --port ${port + 1}`
+  };
+}
+
+function checkEnvFile() {
+  const envPath = path.resolve(process.cwd(), '.env.local');
+  const exists = fs.existsSync(envPath);
+  let hasApiUrl = false;
+  if (exists) {
+    try {
+      const content = fs.readFileSync(envPath, 'utf8');
+      hasApiUrl = /SPAPS_API_URL\s*=/.test(content);
+    } catch {}
+  }
+  return {
+    check: 'env_file',
+    success: exists && hasApiUrl,
+    details: { path: envPath, exists, hasApiUrl },
+    fix: exists ? (hasApiUrl ? null : 'Add SPAPS_API_URL to .env.local (http://localhost:3300)') : 'Run: npx spaps init'
+  };
+}
+
+function checkWritePermissions() {
+  const dir = path.resolve(process.cwd(), '.spaps');
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const tmp = path.join(dir, '_doctor.tmp');
+    fs.writeFileSync(tmp, 'ok');
+    fs.unlinkSync(tmp);
+    return { check: 'write_permissions', success: true, details: { dir }, fix: null };
+  } catch (e) {
+    return { check: 'write_permissions', success: false, details: { dir, error: e.message }, fix: `Make directory writable: chmod -R u+rw ${dir}` };
+  }
+}
+
+function checkSDKInstalled() {
+  try {
+    require.resolve('spaps-sdk', { paths: [process.cwd()] });
+    return { check: 'sdk_installed', success: true, details: { package: 'spaps-sdk' }, fix: null };
+  } catch {
+    return { check: 'sdk_installed', success: false, details: { package: 'spaps-sdk' }, fix: 'npm install spaps-sdk' };
+  }
+}
+
+function checkStripeMode(stripeModeOpt) {
+  const mode = (stripeModeOpt || (process.env.USE_REAL_STRIPE === 'false' ? 'mock' : 'real')).toLowerCase();
+  const needsKey = mode === 'real';
+  const hasKey = Boolean(process.env.STRIPE_SECRET_KEY);
+  const ok = mode === 'mock' || (mode === 'real' && hasKey);
+  return {
+    check: 'stripe_mode',
+    success: ok,
+    details: { mode, needsKey, hasKey },
+    fix: ok ? null : (mode === 'real' ? 'Set STRIPE_SECRET_KEY or run with --stripe mock' : null)
+  };
+}
+
+function checkEnvTest() {
+  const envPath = path.resolve(process.cwd(), '.env.test');
+  if (!fs.existsSync(envPath)) {
+    return {
+      check: 'env_test',
+      success: false,
+      details: { path: envPath, exists: false },
+      fix: 'Create .env.test with SPAPS_API_URL=http://localhost:3300 (no real network keys)'
+    };
+  }
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const hasLocalUrl = /SPAPS_API_URL\s*=\s*http:\/\/localhost:\d+/.test(content);
+    const hasApiKey = /SPAPS_API_KEY\s*=\s*\S+/.test(content);
+    const warns = [];
+    if (!hasLocalUrl) warns.push('SPAPS_API_URL should point to localhost');
+    if (hasApiKey) warns.push('SPAPS_API_KEY should not be set in tests');
+    return {
+      check: 'env_test',
+      success: hasLocalUrl && !hasApiKey,
+      details: { path: envPath, hasLocalUrl, hasApiKey },
+      fix: warns.length ? warns.join(' | ') : null
+    };
+  } catch (e) {
+    return { check: 'env_test', success: false, details: { error: e.message }, fix: 'Ensure .env.test is readable' };
+  }
+}
+
+async function checkNextJsPort() {
+  const defaultNextPort = 3000;
+  const inUse = await new Promise((resolve) => {
+    const tester = net.createServer()
+      .once('error', () => resolve(true))
+      .once('listening', () => tester.once('close', () => resolve(false)).close())
+      .listen(defaultNextPort, '127.0.0.1');
+  });
+  return {
+    check: 'next_port',
+    success: true,
+    details: { port: defaultNextPort, inUse, note: inUse ? 'Next.js likely running (good)' : 'Port free' },
+    fix: null
+  };
+}
+
+async function checkWebhook(port) {
+  const status = await getServerStatus(port);
+  if (!status.running) {
+    return {
+      check: 'webhook',
+      success: false,
+      details: { running: false },
+      fix: `Start server: npx spaps local --port ${port} --stripe mock`
+    };
+  }
+  try {
+    const http = require('http');
+    const payload = JSON.stringify({ id: 'evt_doctor_' + Date.now(), type: 'checkout.session.completed', data: { object: { id: 'cs_doctor_' + Date.now() } } });
+    const ok = await new Promise((resolve) => {
+      const req = http.request({ hostname: 'localhost', port, path: '/api/stripe/webhooks', method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } }, (res) => {
+        resolve(res.statusCode >= 200 && res.statusCode < 300);
+      });
+      req.on('error', () => resolve(false));
+      req.write(payload);
+      req.end();
+    });
+    return { check: 'webhook', success: ok, details: { path: '/api/stripe/webhooks' }, fix: ok ? null : 'Use --stripe mock or ensure webhook handler is reachable' };
+  } catch (e) {
+    return { check: 'webhook', success: false, details: { error: e.message }, fix: 'Use --stripe mock or ensure server is running' };
+  }
+}
+
+function formatHuman(results) {
+  const ok = results.every(r => r.success);
+  console.log(chalk.yellow('\n🍠 SPAPS Doctor\n'));
+  results.forEach(r => {
+    const icon = r.success ? chalk.green('✔') : chalk.red('✖');
+    console.log(`${icon} ${r.check} ${chalk.gray(JSON.stringify(r.details))}`);
+    if (!r.success && r.fix) console.log(chalk.cyan(`   fix: ${r.fix}`));
+  });
+  console.log();
+  console.log(ok ? chalk.green('All checks passed!') : chalk.red('Some checks failed. See fixes above.'));
+}
+
+async function runDoctor({ port = DEFAULT_PORT, stripe = null, json = false } = {}) {
+  const results = [];
+  results.push(checkNodeVersion());
+  results.push(await checkPort(port));
+  // Warn if using 3000 which often collides with Next.js
+  if (port === 3000) {
+    results.push({
+      check: 'spaps_port_vs_next',
+      success: false,
+      details: { spaps_port: port, suggestion: 'Use 3300 for SPAPS to avoid Next.js conflicts' },
+      fix: 'Run: npx spaps local --port 3300'
+    });
+  } else {
+    results.push({ check: 'spaps_port_vs_next', success: true, details: { spaps_port: port }, fix: null });
+  }
+  results.push(checkEnvFile());
+  results.push(checkWritePermissions());
+  results.push(checkSDKInstalled());
+  results.push(checkStripeMode(stripe));
+  results.push(checkEnvTest());
+  results.push(await checkNextJsPort());
+  results.push(await checkWebhook(port));
+
+  const ok = results.every(r => r.success);
+  const payload = { success: ok, results, next_steps: ok ? [] : ['Apply suggested fixes and re-run: npx spaps doctor --json'] };
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    formatHuman(results);
+  }
+  return payload;
+}
+
+module.exports = { runDoctor };