asasvirtuais 0.1.0

package/lib/client-token-storage.ts

@@ -0,0 +1,216 @@
+'use client'
+
+// Client-side token storage using IndexedDB for security
+// IndexedDB is more secure than localStorage because:
+// 1. Data is not automatically sent with every HTTP request
+// 2. Larger storage capacity
+// 3. Better performance for complex data
+// 4. Data is structured and can be queried
+
+const DB_NAME = 'OAuthTokensDB'
+const DB_VERSION = 1
+const STORE_NAME = 'tokens'
+
+interface ClientToken {
+    id: string // platform id
+    platform: string
+    accessToken: string
+    expiresAt?: string
+    lastRefreshed: string
+}
+
+class TokenStorage {
+    private db: IDBDatabase | null = null
+
+    async init(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(DB_NAME, DB_VERSION)
+
+            request.onerror = () => reject(request.error)
+            request.onsuccess = () => {
+                this.db = request.result
+                resolve()
+            }
+
+            request.onupgradeneeded = (event) => {
+                const db = (event.target as IDBOpenDBRequest).result
+                
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    const store = db.createObjectStore(STORE_NAME, { keyPath: 'id' })
+                    store.createIndex('platform', 'platform', { unique: false })
+                    store.createIndex('lastRefreshed', 'lastRefreshed', { unique: false })
+                }
+            }
+        })
+    }
+
+    private async ensureDB(): Promise<IDBDatabase> {
+        if (!this.db) {
+            await this.init()
+        }
+        if (!this.db) {
+            throw new Error('Failed to initialize IndexedDB')
+        }
+        return this.db
+    }
+
+    async storeToken(token: ClientToken): Promise<void> {
+        const db = await this.ensureDB()
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([STORE_NAME], 'readwrite')
+            const store = transaction.objectStore(STORE_NAME)
+            
+            const request = store.put({
+                ...token,
+                lastRefreshed: new Date().toISOString()
+            })
+
+            request.onsuccess = () => resolve()
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    async getToken(platformId: string): Promise<ClientToken | null> {
+        const db = await this.ensureDB()
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([STORE_NAME], 'readonly')
+            const store = transaction.objectStore(STORE_NAME)
+            const request = store.get(platformId)
+
+            request.onsuccess = () => {
+                const token = request.result
+                if (token && token.expiresAt) {
+                    // Check if token is expired
+                    const expiryDate = new Date(token.expiresAt)
+                    if (expiryDate < new Date()) {
+                        // Token is expired, remove it
+                        this.removeToken(platformId)
+                        resolve(null)
+                        return
+                    }
+                }
+                resolve(token || null)
+            }
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    async getAllTokens(): Promise<ClientToken[]> {
+        const db = await this.ensureDB()
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([STORE_NAME], 'readonly')
+            const store = transaction.objectStore(STORE_NAME)
+            const request = store.getAll()
+
+            request.onsuccess = () => {
+                const tokens = request.result || []
+                // Filter out expired tokens
+                const validTokens = tokens.filter(token => {
+                    if (token.expiresAt) {
+                        const expiryDate = new Date(token.expiresAt)
+                        return expiryDate > new Date()
+                    }
+                    return true
+                })
+                resolve(validTokens)
+            }
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    async removeToken(platformId: string): Promise<void> {
+        const db = await this.ensureDB()
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([STORE_NAME], 'readwrite')
+            const store = transaction.objectStore(STORE_NAME)
+            const request = store.delete(platformId)
+
+            request.onsuccess = () => resolve()
+            request.onerror = () => reject(request.error)
+        })
+    }
+
+    async clearAll(): Promise<void> {
+        const db = await this.ensureDB()
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([STORE_NAME], 'readwrite')
+            const store = transaction.objectStore(STORE_NAME)
+            const request = store.clear()
+
+            request.onsuccess = () => resolve()
+            request.onerror = () => reject(request.error)
+        })
+    }
+}
+
+// Export a singleton instance
+export const tokenStorage = new TokenStorage()
+
+// Helper function to check if IndexedDB is available
+export function isIndexedDBAvailable(): boolean {
+    try {
+        return typeof window !== 'undefined' && 'indexedDB' in window
+    } catch {
+        return false
+    }
+}
+
+// Fallback to sessionStorage if IndexedDB is not available
+// SessionStorage is safer than localStorage for sensitive data
+export class FallbackStorage {
+    private prefix = 'oauth_token_'
+
+    storeToken(token: ClientToken): void {
+        if (typeof window !== 'undefined') {
+            sessionStorage.setItem(this.prefix + token.id, JSON.stringify(token))
+        }
+    }
+
+    getToken(platformId: string): ClientToken | null {
+        if (typeof window !== 'undefined') {
+            const data = sessionStorage.getItem(this.prefix + platformId)
+            return data ? JSON.parse(data) : null
+        }
+        return null
+    }
+
+    getAllTokens(): ClientToken[] {
+        const tokens: ClientToken[] = []
+        if (typeof window !== 'undefined') {
+            for (let i = 0; i < sessionStorage.length; i++) {
+                const key = sessionStorage.key(i)
+                if (key?.startsWith(this.prefix)) {
+                    const data = sessionStorage.getItem(key)
+                    if (data) {
+                        tokens.push(JSON.parse(data))
+                    }
+                }
+            }
+        }
+        return tokens
+    }
+
+    removeToken(platformId: string): void {
+        if (typeof window !== 'undefined') {
+            sessionStorage.removeItem(this.prefix + platformId)
+        }
+    }
+
+    clearAll(): void {
+        if (typeof window !== 'undefined') {
+            const keysToRemove: string[] = []
+            for (let i = 0; i < sessionStorage.length; i++) {
+                const key = sessionStorage.key(i)
+                if (key?.startsWith(this.prefix)) {
+                    keysToRemove.push(key)
+                }
+            }
+            keysToRemove.forEach(key => sessionStorage.removeItem(key))
+        }
+    }
+}
+
+export const fallbackStorage = new FallbackStorage()
+
+// Main export that automatically uses the best available storage
+export const clientTokenStorage = isIndexedDBAvailable() ? tokenStorage : fallbackStorage

package/lib/oauth-tokens.ts

@@ -0,0 +1,85 @@
+// Token storage utilities
+// In production, these should be stored in a secure database with encryption
+
+interface StoredToken {
+    userId: string
+    platform: string
+    accessToken: string
+    refreshToken?: string
+    expiresAt?: Date
+    scopes: string[]
+    createdAt: Date
+    updatedAt: Date
+}
+
+// Temporary in-memory storage for development
+// Replace with database in production
+const tokenStore = new Map<string, StoredToken>()
+
+export function getTokenKey(userId: string, platform: string): string {
+    return `${userId}:${platform}`
+}
+
+export async function storeToken(token: Omit<StoredToken, 'createdAt' | 'updatedAt'>): Promise<void> {
+    const key = getTokenKey(token.userId, token.platform)
+    const storedToken: StoredToken = {
+        ...token,
+        createdAt: new Date(),
+        updatedAt: new Date()
+    }
+    
+    tokenStore.set(key, storedToken)
+    
+    // In production:
+    // - Encrypt the tokens
+    // - Store in database
+    // - Set up automatic refresh based on expiresAt
+}
+
+export async function getToken(userId: string, platform: string): Promise<StoredToken | null> {
+    const key = getTokenKey(userId, platform)
+    const token = tokenStore.get(key)
+    
+    if (!token) return null
+    
+    // Check if token is expired
+    if (token.expiresAt && new Date() > token.expiresAt) {
+        // In production, attempt to refresh the token here
+        return null
+    }
+    
+    return token
+}
+
+export async function removeToken(userId: string, platform: string): Promise<boolean> {
+    const key = getTokenKey(userId, platform)
+    return tokenStore.delete(key)
+}
+
+export async function getUserTokens(userId: string): Promise<StoredToken[]> {
+    const tokens: StoredToken[] = []
+    
+    for (const [key, token] of tokenStore.entries()) {
+        if (key.startsWith(`${userId}:`)) {
+            tokens.push(token)
+        }
+    }
+    
+    return tokens
+}
+
+// Utility to encrypt tokens before storage (implement in production)
+export function encryptToken(token: string): string {
+    // In production, use proper encryption (e.g., AES-256)
+    // For now, return as-is
+    console.warn('Token encryption not implemented - use only in development')
+    return token
+}
+
+// Utility to decrypt tokens after retrieval (implement in production)
+export function decryptToken(encryptedToken: string): string {
+    // In production, use proper decryption
+    // For now, return as-is
+    console.warn('Token decryption not implemented - use only in development')
+    return encryptedToken
+}

package/lib/react/context.tsx

@@ -0,0 +1,20 @@
+/** This is one of the lines of code that I haven't had to change, keep it like that */
+import React from 'react'
+
+export function createContextFromHook<Props, Result>(useHook: (props: Props) => Result) {
+
+    const Context = React.createContext<Result | undefined>(undefined)
+
+    function Provider( { children, ...props}: React.PropsWithChildren<Props> ) {
+
+        const value = useHook(props as Props) as Result
+
+        return <Context.Provider value={value}>{ children }</Context.Provider>
+    }
+
+    function useContext() {
+        return React.useContext(Context) as Result
+    }
+
+    return [Provider, useContext] as const
+}

package/lib/react/index.ts

@@ -0,0 +1 @@
+export * from './context'

package/lib/tools.ts

@@ -0,0 +1,375 @@
+import { z } from 'zod'
+
+export type ServerTool = {
+  description: string
+  parameters: any
+  execute: (args: any) => Promise<any> | any
+}
+
+import { server } from '@/app/server'
+import { drawAction } from '@/actions/draw'
+import { uploadBuffer, getPublicUrl } from '@/packages/blob'
+import crypto from 'crypto'
+
+export const serverTools: Record<string, ServerTool> = {
+  inner_monologue: {
+    description: 'Record thoughts text associated with a character. Provide thoughts and characterId (the CHARACTER ID, not the name).',
+    parameters: z.object({
+      thoughts: z.string().describe('Thoughts as a plain string'),
+      characterId: z.string().describe('The ID of the character these thoughts belong to (not the name)')
+    }),
+    execute: async ({ thoughts, characterId }: { thoughts: string; characterId: string }) => {
+      // First try to find by id
+      try {
+        const character = await server.characters.find({ id: characterId })
+        return { thoughts, characterId, character }
+      } catch (e) {
+        // If not found, attempt to treat the provided characterId as a name and try to lookup by name
+        try {
+          const list = await server.characters.list({ query: { name: characterId } })
+          if (Array.isArray(list) && list.length > 0) {
+            const found = list[0] as Character
+            return { thoughts, characterId: found.id, character: found }
+          }
+        } catch (_) {}
+        // fallback: return what we have
+        return { thoughts, characterId }
+      }
+    }
+  },
+  generate_image: {
+    description: 'Generate an image from a prompt',
+    parameters: z.object({ prompt: z.string(), orientation: z.enum(['portrait', 'landscape', 'square']).optional() }),
+    execute: async ({ prompt, orientation = 'square' }: { prompt: string, orientation?: 'portrait' | 'landscape' | 'square' }) => {
+      // Call the server action which returns a data URL (or throws)
+      const dataUrl = await drawAction({ prompt, orientation })
+      // dataUrl expected like: data:image/png;base64,<base64data>
+      const match = /^data:(.+);base64,(.+)$/.exec(dataUrl)
+      if (!match) throw new Error('Invalid image data returned')
+      const contentType = match[1]
+      const base64 = match[2]
+      const buffer = Buffer.from(base64, 'base64')
+
+      // generate a filename
+      const filename = `generated/${Date.now()}-${crypto.randomBytes(6).toString('hex')}.png`
+      const publicUrl = await uploadBuffer(buffer, filename, contentType)
+
+      // For LLMs only return a short confirmation string — no image bytes or base64
+      return {
+        confirmation: 'image_generated',
+        prompt,
+        orientation,
+        imageUrl: publicUrl,
+        filename,
+      }
+    }
+  },
+  photograph: {
+    description: 'Generate a photograph of a character. Provide characterId and lists of image-board tags for position, background, viewpoint, and action.',
+    parameters: z.object({
+      characterId: z.string(),
+      position: z.string().describe('A couple of image-board tags for the character positiion'),
+      background: z.string().describe('A couple of image-board tags for the background scene'),
+      viewpoint: z.string().describe('A couple of image-board tags for the point of view of the photograph'),
+      action: z.string().describe('A couple of image-board tags for the action taken in the scene'),
+      nsfw: z.string().describe('A list of nsfw tags if applicable to the scene'),
+      orientation: z.enum(['portrait', 'landscape', 'square']).optional()
+    }),
+    execute: async ({ characterId, position, background, viewpoint, nsfw, action, orientation = 'portrait' }:
+      { characterId: string, position?: string, background?: string, viewpoint?: string, action?: string, nsfw?: string, orientation?: 'portrait'|'landscape'|'square' }) => {
+      // Load character and assemble tag prompt
+      const character = await server.characters.find({ id: characterId })
+      // Assume `appearance` and `personality` fields are comma-separated image-board tags
+      const appearanceTags = (character?.appearance || '').split(',').map((s: string) => s.trim()).filter(Boolean)
+      const personalityTags = (character?.personality || '').split(',').map((s: string) => s.trim()).filter(Boolean)
+
+      const parts = [
+        ...(appearanceTags),
+        ...(personalityTags),
+        ...(position ? [position] : []),
+        ...(background ? [background] : []),
+        ...(viewpoint ? [viewpoint] : []),
+        ...(action ? [action] : []),
+        ...(nsfw ? [nsfw] : []),
+      ].filter(Boolean)
+
+      const prompt = parts.join(', ')
+
+      // Use drawAction to generate the image
+      const publicUrl = await drawAction({ prompt, orientation })
+      const filename = `photograph/${characterId}/${Date.now()}-${crypto.randomBytes(6).toString('hex')}.png`
+
+      return {
+        characterId,
+        promptSummary: prompt.substring(0, 500),
+        imageUrl: publicUrl,
+        filename,
+      }
+    }
+  },
+  create_character: {
+    description: 'Create a new character with name, personality, appearance, and definition. Returns the created character.',
+    parameters: z.object({
+      name: z.string().describe('Character name'),
+      personality: z.string().describe('Character personality description (image-board tags only)'),
+      appearance: z.string().describe('Character appearance description (image-board tags only)'),
+      definition: z.string().describe('Full character definition and background'),
+    }),
+    execute: async ({ name, personality, appearance, definition }: Character.Writable) => {
+      // Store personality and appearance exactly as provided (no normalization)
+      const created = await server.characters.create({ data: { name, personality, appearance, definition } })
+      return created
+    }
+  },
+  
+  // Page management tools for SEO content
+  create_page: {
+    description: 'Create a complete SEO-optimized page with all sections (hero, features, content, FAQ, testimonials, CTA). Perfect for generating landing pages from simple prompts.',
+    parameters: z.object({
+      slug: z.string().describe('URL slug for the page (e.g., "organic-dog-food", "premium-yoga-classes")'),
+      title: z.string().describe('SEO page title'),
+      description: z.string().describe('SEO meta description'),
+      keywords: z.array(z.string()).describe('SEO keywords array'),
+      author: z.string().describe('Content author name'),
+      canonical: z.string().describe('Canonical URL for the page'),
+      ogImage: z.string().describe('Open Graph image URL'),
+      hero: z.object({
+        headline: z.string().describe('Main hero headline'),
+        subheadline: z.string().describe('Supporting subheadline'),
+        description: z.string().describe('Hero description text'),
+        ctaText: z.string().describe('Hero CTA button text'),
+        ctaUrl: z.string().describe('Hero CTA button URL'),
+      }).describe('Hero section content'),
+      features: z.object({
+        heading: z.string().describe('Features section heading'),
+        items: z.array(z.object({
+          title: z.string(),
+          description: z.string(),
+        })).describe('Feature items list'),
+      }).describe('Features section'),
+      content: z.string().describe('Main content in markdown format'),
+      faq: z.object({
+        heading: z.string().describe('FAQ section heading'),
+        items: z.array(z.object({
+          question: z.string(),
+          answer: z.string(),
+        })).describe('FAQ items'),
+      }).describe('FAQ section'),
+      testimonials: z.object({
+        heading: z.string().describe('Testimonials section heading'),
+        items: z.array(z.object({
+          name: z.string(),
+          role: z.string(),
+          content: z.string(),
+          rating: z.number().min(1).max(5).optional(),
+        })).describe('Customer testimonials'),
+      }).describe('Testimonials section'),
+      cta: z.object({
+        heading: z.string().describe('Final CTA heading'),
+        description: z.string().describe('CTA description'),
+        buttonText: z.string().describe('CTA button text'),
+        buttonUrl: z.string().describe('CTA button URL'),
+      }).describe('Call-to-action section'),
+    }),
+    execute: async ({ 
+      slug, title, description, keywords, author, canonical, ogImage,
+      hero, features, content, faq, testimonials, cta 
+    }: any) => {
+      // Build the complete page data structure with new schema
+      const pageData: Page.Writable = {
+        slug,
+        title,
+        description,
+        keywords,
+        author,
+        canonical,
+        og: {
+          title,
+          description,
+          image: ogImage,
+        },
+        hero,
+        features,
+        content,
+        faq,
+        testimonials,
+        cta,
+      }
+
+      const created = await server.pages.create({ data: pageData })
+      return {
+        success: true,
+        page: created,
+        message: `Successfully created SEO page "${title}" with slug "${slug}"`,
+      }
+    }
+  },
+
+  find_page: {
+    description: 'Find a specific SEO page by ID. Returns the complete page with all sections.',
+    parameters: z.object({
+      id: z.string().describe('The page ID to find'),
+    }),
+    execute: async ({ id }: { id: string }) => {
+      try {
+        const page = await server.pages.find({ id })
+        return {
+          success: true,
+          page,
+          message: `Found page: ${page.title}`,
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Page with ID ${id} not found`,
+        }
+      }
+    }
+  },
+
+  list_pages: {
+    description: 'List all SEO pages. Returns an array of pages with basic info.',
+    parameters: z.object({
+      limit: z.number().optional().describe('Maximum number of pages to return'),
+    }),
+    execute: async ({ limit }: { limit?: number }) => {
+      try {
+        const query: any = {}
+        if (limit) query.$limit = limit
+
+        const pages = await server.pages.list({ query })
+        return {
+          success: true,
+          pages: pages.map(page => ({
+            id: page.id,
+            slug: page.slug,
+            title: page.title,
+            description: page.description,
+            createdAt: page.createdAt,
+            updatedAt: page.updatedAt,
+          })),
+          count: pages.length,
+          message: `Found ${pages.length} page(s)`,
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: 'Failed to retrieve pages',
+        }
+      }
+    }
+  },
+
+  update_page: {
+    description: 'Update an existing SEO page. Provide the page ID and any fields or sections to update.',
+    parameters: z.object({
+      id: z.string().describe('The page ID to update'),
+      slug: z.string().optional().describe('New URL slug'),
+      title: z.string().optional().describe('New page title'),
+      description: z.string().optional().describe('New meta description'),
+      keywords: z.array(z.string()).optional().describe('New keywords'),
+      author: z.string().optional().describe('New content author'),
+      canonical: z.string().optional().describe('New canonical URL'),
+      ogImage: z.string().optional().describe('New Open Graph image URL'),
+      hero: z.object({
+        headline: z.string().optional(),
+        subheadline: z.string().optional(),
+        description: z.string().optional(),
+        ctaText: z.string().optional(),
+        ctaUrl: z.string().optional(),
+      }).optional().describe('Hero section updates'),
+      features: z.object({
+        heading: z.string().optional(),
+        items: z.array(z.object({
+          title: z.string(),
+          description: z.string(),
+        })).optional(),
+      }).optional().describe('Features section updates'),
+      content: z.string().optional().describe('Main content updates'),
+      faq: z.object({
+        heading: z.string().optional(),
+        items: z.array(z.object({
+          question: z.string(),
+          answer: z.string(),
+        })).optional(),
+      }).optional().describe('FAQ updates'),
+      testimonials: z.object({
+        heading: z.string().optional(),
+        items: z.array(z.object({
+          name: z.string(),
+          role: z.string(),
+          content: z.string(),
+          rating: z.number().min(1).max(5).optional(),
+        })).optional(),
+      }).optional().describe('Testimonials updates'),
+      cta: z.object({
+        heading: z.string().optional(),
+        description: z.string().optional(),
+        buttonText: z.string().optional(),
+        buttonUrl: z.string().optional(),
+      }).optional().describe('CTA updates'),
+    }),
+    execute: async ({ id, ogImage, ...updates }: any) => {
+      try {
+        // First fetch the existing page to preserve required fields
+        const existingPage = await server.pages.find({ id })
+        
+        const updateData: any = {}
+        
+        // Handle the Open Graph object - preserve existing values and update as needed
+        if (ogImage || updates.title || updates.description) {
+          updateData.og = {
+            title: updates.title || existingPage.og.title,
+            description: updates.description || existingPage.og.description,
+            image: ogImage || existingPage.og.image,
+          }
+        }
+        
+        // Copy over any other provided updates (excluding title/description since they're handled in og)
+        Object.keys(updates).forEach(key => {
+          if (updates[key] !== undefined && key !== 'title' && key !== 'description') {
+            updateData[key] = updates[key]
+          }
+        })
+        
+        // Handle title and description separately (they go to both root and og)
+        if (updates.title) updateData.title = updates.title
+        if (updates.description) updateData.description = updates.description
+
+        const updated = await server.pages.update({ id, data: updateData })
+        return {
+          success: true,
+          page: updated,
+          message: `Successfully updated page "${updated.title}"`,
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to update page with ID ${id}: ${error.message || error}`,
+        }
+      }
+    }
+  },
+
+  delete_page: {
+    description: 'Delete an SEO page by ID. This action cannot be undone.',
+    parameters: z.object({
+      id: z.string().describe('The page ID to delete'),
+    }),
+    execute: async ({ id }: { id: string }) => {
+      try {
+        const deleted = await server.pages.remove({ id })
+        return {
+          success: true,
+          deletedPage: deleted,
+          message: `Successfully deleted page: ${deleted.title}`,
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to delete page with ID ${id}`,
+        }
+      }
+    }
+  }
+}