create-fluxstack 1.0.22 → 1.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-fluxstack",
-  "version": "1.0.22",
-  "description": "⚡ Modern full-stack TypeScript framework with Elysia + React + Bun",
+  "version": "1.1.0",
+  "description": "⚡ Revolutionary full-stack TypeScript framework with Temporal Bridge Auto-Discovery, Elysia + React + Bun",
   "keywords": [
     "framework",
     "full-stack",
@@ -29,7 +29,7 @@
     "dev:backend": "bun run core/cli/index.ts backend",
     "dev:coordinated": "concurrently --prefix {name} --names BACKEND,VITE --prefix-colors blue,green --kill-others-on-fail \"bun --watch app/server/index.ts\" \"vite --config vite.config.ts\"",
     "dev:clean": "bun run run-clean.ts",
-    "build": "bun run core/cli/index.ts build",
+    "build": "cross-env NODE_ENV=production bun run core/cli/index.ts build",
     "build:frontend": "vite build --config vite.config.ts --emptyOutDir",
     "build:backend": "bun run core/cli/index.ts build:backend",
     "start": "bun run core/cli/index.ts start",
@@ -70,6 +70,7 @@
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "concurrently": "^9.2.0",
+    "cross-env": "^10.1.0",
     "eslint": "^9.30.1",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.20",

package/plugins/crypto-auth/README.md

@@ -0,0 +1,238 @@
+# FluxStack Crypto Auth Plugin
+
+Plugin de autenticação criptográfica baseado em Ed25519 para FluxStack.
+
+## Características
+
+- 🔐 **Zero-friction auth** - Sem cadastros, senhas ou emails
+- ✅ **Criptografia Ed25519** - Assinatura criptográfica de todas as requisições
+- 🌐 **Cross-platform** - Funciona em qualquer ambiente JavaScript
+- 💾 **Stateless backend** - Não precisa de banco para autenticação
+- 🎨 **Componentes React** - Componentes prontos para uso
+- ⚡ **Integração FluxStack** - Plugin nativo do FluxStack
+
+## Instalação
+
+```bash
+# O plugin já está incluído na pasta plugins/
+# Apenas habilite no fluxstack.config.ts
+```
+
+## Configuração
+
+No seu `fluxstack.config.ts`:
+
+```typescript
+export const config: FluxStackConfig = {
+  // ... outras configurações
+  
+  plugins: {
+    enabled: ['crypto-auth'],
+    config: {
+      'crypto-auth': {
+        enabled: true,
+        sessionTimeout: 1800000, // 30 minutos
+        maxTimeDrift: 300000, // 5 minutos
+        adminKeys: [
+          'sua_chave_publica_admin_aqui'
+        ],
+        protectedRoutes: [
+          '/api/admin/*',
+          '/api/protected/*'
+        ],
+        publicRoutes: [
+          '/api/auth/*',
+          '/api/health',
+          '/api/docs'
+        ],
+        enableMetrics: true
+      }
+    }
+  }
+}
+```
+
+## Uso no Frontend
+
+### 1. Configurar o Provider
+
+```tsx
+import React from 'react'
+import { AuthProvider } from '@/plugins/crypto-auth/client'
+
+function App() {
+  return (
+    <AuthProvider
+      config={{
+        apiBaseUrl: 'http://localhost:3000',
+        storage: 'localStorage'
+      }}
+      onAuthChange={(isAuth, session) => {
+        console.log('Auth changed:', isAuth, session)
+      }}
+    >
+      <YourApp />
+    </AuthProvider>
+  )
+}
+```
+
+### 2. Usar o Hook de Autenticação
+
+```tsx
+import React from 'react'
+import { useAuth } from '@/plugins/crypto-auth/client'
+
+function Dashboard() {
+  const { 
+    isAuthenticated, 
+    isAdmin, 
+    permissions, 
+    login, 
+    logout,
+    client 
+  } = useAuth()
+
+  const handleApiCall = async () => {
+    try {
+      const response = await client.fetch('/api/protected/data')
+      const data = await response.json()
+      console.log(data)
+    } catch (error) {
+      console.error('Erro na API:', error)
+    }
+  }
+
+  if (!isAuthenticated) {
+    return <button onClick={login}>Entrar</button>
+  }
+
+  return (
+    <div>
+      <h1>Dashboard {isAdmin && '(Admin)'}</h1>
+      <p>Permissões: {permissions.join(', ')}</p>
+      <button onClick={handleApiCall}>Chamar API</button>
+      <button onClick={logout}>Sair</button>
+    </div>
+  )
+}
+```
+
+### 3. Componentes Prontos
+
+```tsx
+import React from 'react'
+import { 
+  LoginButton, 
+  ProtectedRoute, 
+  SessionInfo 
+} from '@/plugins/crypto-auth/client'
+
+function MyApp() {
+  return (
+    <div>
+      {/* Botão de login/logout */}
+      <LoginButton 
+        onLogin={(session) => console.log('Logado:', session)}
+        onLogout={() => console.log('Deslogado')}
+        showPermissions={true}
+      />
+
+      {/* Rota protegida */}
+      <ProtectedRoute requireAdmin={true}>
+        <AdminPanel />
+      </ProtectedRoute>
+
+      {/* Informações da sessão */}
+      <SessionInfo 
+        showPrivateKey={false}
+        compact={true}
+      />
+    </div>
+  )
+}
+```
+
+### 4. HOC para Proteção
+
+```tsx
+import { withAuth } from '@/plugins/crypto-auth/client'
+
+const AdminComponent = () => <div>Área Admin</div>
+
+// Proteger componente
+const ProtectedAdmin = withAuth(AdminComponent, {
+  requireAdmin: true,
+  requiredPermissions: ['admin']
+})
+```
+
+## Uso no Backend
+
+O plugin automaticamente:
+
+- Registra rotas de autenticação em `/api/auth/*`
+- Aplica middleware de autenticação nas rotas protegidas
+- Valida assinaturas Ed25519 em cada requisição
+- Gerencia sessões em memória
+
+### Rotas Automáticas
+
+- `POST /api/auth/session/init` - Inicializar sessão
+- `POST /api/auth/session/validate` - Validar sessão
+- `GET /api/auth/session/info` - Informações da sessão
+- `POST /api/auth/session/logout` - Encerrar sessão
+
+### Acessar Usuário nas Rotas
+
+```typescript
+// Em suas rotas FluxStack
+app.get('/api/protected/data', ({ user }) => {
+  // user estará disponível se autenticado
+  if (!user) {
+    return { error: 'Não autenticado' }
+  }
+  
+  return {
+    message: 'Dados protegidos',
+    user: {
+      sessionId: user.sessionId,
+      isAdmin: user.isAdmin,
+      permissions: user.permissions
+    }
+  }
+})
+```
+
+## Como Funciona
+
+1. **Cliente gera** par de chaves Ed25519 automaticamente
+2. **Session ID** = chave pública (64 chars hex)
+3. **Todas as requisições** são assinadas com a chave privada
+4. **Backend valida** a assinatura Ed25519 em cada request
+5. **Admin access** via chaves públicas autorizadas
+
+## Segurança
+
+- ✅ Assinatura Ed25519 em todas as requisições
+- ✅ Nonce para prevenir replay attacks  
+- ✅ Validação de timestamp (5 min máximo)
+- ✅ Timeout de sessões (30 min padrão)
+- ✅ Chaves privadas nunca saem do cliente
+- ✅ Stateless - sem dependência de banco de dados
+
+## Desenvolvimento
+
+Para desenvolver o plugin:
+
+```bash
+# Instalar dependências
+npm install @noble/curves @noble/hashes
+
+# Para desenvolvimento com React
+npm install --save-dev @types/react react
+```
+
+## Licença
+
+MIT

package/plugins/crypto-auth/client/CryptoAuthClient.ts

@@ -0,0 +1,325 @@
+/**
+ * Cliente de Autenticação Criptográfica
+ * Gerencia autenticação no lado do cliente
+ */
+
+import { ed25519 } from '@noble/curves/ed25519'
+import { sha256 } from '@noble/hashes/sha256'
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
+
+export interface SessionInfo {
+  sessionId: string
+  publicKey: string
+  privateKey: string
+  isAdmin: boolean
+  permissions: string[]
+  createdAt: Date
+  lastUsed: Date
+}
+
+export interface AuthConfig {
+  apiBaseUrl?: string
+  storage?: 'localStorage' | 'sessionStorage' | 'memory'
+  autoInit?: boolean
+  sessionTimeout?: number
+}
+
+export interface SignedRequestOptions extends RequestInit {
+  skipAuth?: boolean
+}
+
+export class CryptoAuthClient {
+  private session: SessionInfo | null = null
+  private config: AuthConfig
+  private storage: Storage | Map<string, string>
+
+  constructor(config: AuthConfig = {}) {
+    this.config = {
+      apiBaseUrl: '',
+      storage: 'localStorage',
+      autoInit: true,
+      sessionTimeout: 1800000, // 30 minutos
+      ...config
+    }
+
+    // Configurar storage
+    if (this.config.storage === 'localStorage' && typeof localStorage !== 'undefined') {
+      this.storage = localStorage
+    } else if (this.config.storage === 'sessionStorage' && typeof sessionStorage !== 'undefined') {
+      this.storage = sessionStorage
+    } else {
+      this.storage = new Map<string, string>()
+    }
+
+    // Auto-inicializar se configurado
+    if (this.config.autoInit) {
+      this.initialize()
+    }
+  }
+
+  /**
+   * Inicializar sessão
+   */
+  async initialize(): Promise<SessionInfo> {
+    // Tentar carregar sessão existente
+    const existingSession = this.loadSession()
+    if (existingSession && this.isSessionValid(existingSession)) {
+      this.session = existingSession
+      return existingSession
+    }
+
+    // Criar nova sessão
+    return this.createNewSession()
+  }
+
+  /**
+   * Criar nova sessão
+   */
+  async createNewSession(): Promise<SessionInfo> {
+    try {
+      // Gerar par de chaves
+      const privateKey = ed25519.utils.randomPrivateKey()
+      const publicKey = ed25519.getPublicKey(privateKey)
+      
+      const sessionId = bytesToHex(publicKey)
+      const privateKeyHex = bytesToHex(privateKey)
+
+      // Registrar sessão no servidor
+      const response = await fetch(`${this.config.apiBaseUrl}/api/auth/session/init`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          publicKey: sessionId
+        })
+      })
+
+      if (!response.ok) {
+        throw new Error(`Erro ao inicializar sessão: ${response.statusText}`)
+      }
+
+      const result = await response.json()
+      if (!result.success) {
+        throw new Error(result.error || 'Erro desconhecido ao inicializar sessão')
+      }
+
+      // Criar objeto de sessão
+      const session: SessionInfo = {
+        sessionId,
+        publicKey: sessionId,
+        privateKey: privateKeyHex,
+        isAdmin: result.user?.isAdmin || false,
+        permissions: result.user?.permissions || ['read'],
+        createdAt: new Date(),
+        lastUsed: new Date()
+      }
+
+      this.session = session
+      this.saveSession(session)
+
+      return session
+    } catch (error) {
+      console.error('Erro ao criar nova sessão:', error)
+      throw error
+    }
+  }
+
+  /**
+   * Fazer requisição autenticada
+   */
+  async fetch(url: string, options: SignedRequestOptions = {}): Promise<Response> {
+    const { skipAuth = false, ...fetchOptions } = options
+
+    if (skipAuth) {
+      return fetch(url, fetchOptions)
+    }
+
+    if (!this.session) {
+      await this.initialize()
+    }
+
+    if (!this.session) {
+      throw new Error('Sessão não inicializada')
+    }
+
+    // Preparar headers de autenticação
+    const timestamp = Date.now()
+    const nonce = this.generateNonce()
+    const message = this.buildMessage(fetchOptions.method || 'GET', url, fetchOptions.body)
+    const signature = this.signMessage(message, timestamp, nonce)
+
+    const headers = {
+      'Content-Type': 'application/json',
+      ...fetchOptions.headers,
+      'x-session-id': this.session.sessionId,
+      'x-timestamp': timestamp.toString(),
+      'x-nonce': nonce,
+      'x-signature': signature
+    }
+
+    // Atualizar último uso
+    this.session.lastUsed = new Date()
+    this.saveSession(this.session)
+
+    return fetch(url, {
+      ...fetchOptions,
+      headers
+    })
+  }
+
+  /**
+   * Obter informações da sessão atual
+   */
+  getSession(): SessionInfo | null {
+    return this.session
+  }
+
+  /**
+   * Verificar se está autenticado
+   */
+  isAuthenticated(): boolean {
+    return this.session !== null && this.isSessionValid(this.session)
+  }
+
+  /**
+   * Verificar se é admin
+   */
+  isAdmin(): boolean {
+    return this.session?.isAdmin || false
+  }
+
+  /**
+   * Obter permissões
+   */
+  getPermissions(): string[] {
+    return this.session?.permissions || []
+  }
+
+  /**
+   * Fazer logout
+   */
+  async logout(): Promise<void> {
+    if (this.session) {
+      try {
+        await this.fetch(`${this.config.apiBaseUrl}/api/auth/session/logout`, {
+          method: 'POST'
+        })
+      } catch (error) {
+        console.warn('Erro ao fazer logout no servidor:', error)
+      }
+
+      this.session = null
+      this.clearSession()
+    }
+  }
+
+  /**
+   * Assinar mensagem
+   */
+  private signMessage(message: string, timestamp: number, nonce: string): string {
+    if (!this.session) {
+      throw new Error('Sessão não inicializada')
+    }
+
+    const fullMessage = `${this.session.sessionId}:${timestamp}:${nonce}:${message}`
+    const messageHash = sha256(new TextEncoder().encode(fullMessage))
+    const privateKeyBytes = hexToBytes(this.session.privateKey)
+    const signature = ed25519.sign(messageHash, privateKeyBytes)
+    
+    return bytesToHex(signature)
+  }
+
+  /**
+   * Construir mensagem para assinatura
+   */
+  private buildMessage(method: string, url: string, body?: any): string {
+    const urlObj = new URL(url, window.location.origin)
+    let message = `${method}:${urlObj.pathname}`
+    
+    if (body) {
+      if (typeof body === 'string') {
+        message += `:${body}`
+      } else {
+        message += `:${JSON.stringify(body)}`
+      }
+    }
+
+    return message
+  }
+
+  /**
+   * Gerar nonce aleatório
+   */
+  private generateNonce(): string {
+    const array = new Uint8Array(16)
+    crypto.getRandomValues(array)
+    return bytesToHex(array)
+  }
+
+  /**
+   * Verificar se sessão é válida
+   */
+  private isSessionValid(session: SessionInfo): boolean {
+    const now = Date.now()
+    const sessionAge = now - session.lastUsed.getTime()
+    return sessionAge < (this.config.sessionTimeout || 1800000)
+  }
+
+  /**
+   * Salvar sessão no storage
+   */
+  private saveSession(session: SessionInfo): void {
+    const sessionData = JSON.stringify({
+      ...session,
+      createdAt: session.createdAt.toISOString(),
+      lastUsed: session.lastUsed.toISOString()
+    })
+
+    if (this.storage instanceof Map) {
+      this.storage.set('crypto-auth-session', sessionData)
+    } else {
+      this.storage.setItem('crypto-auth-session', sessionData)
+    }
+  }
+
+  /**
+   * Carregar sessão do storage
+   */
+  private loadSession(): SessionInfo | null {
+    try {
+      let sessionData: string | null
+
+      if (this.storage instanceof Map) {
+        sessionData = this.storage.get('crypto-auth-session') || null
+      } else {
+        sessionData = this.storage.getItem('crypto-auth-session')
+      }
+
+      if (!sessionData) {
+        return null
+      }
+
+      const parsed = JSON.parse(sessionData)
+      return {
+        ...parsed,
+        createdAt: new Date(parsed.createdAt),
+        lastUsed: new Date(parsed.lastUsed)
+      }
+    } catch (error) {
+      console.warn('Erro ao carregar sessão:', error)
+      return null
+    }
+  }
+
+  /**
+   * Limpar sessão do storage
+   */
+  private clearSession(): void {
+    if (this.storage instanceof Map) {
+      this.storage.delete('crypto-auth-session')
+    } else {
+      this.storage.removeItem('crypto-auth-session')
+    }
+  }
+}