Update apps/aura_measure.js

apps/aura_measure.js

@@ -1,4 +1,310 @@
 
+import express from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { generateCompletion } from '../ai_engine.js';
+import { supabase } from '../config/supabaseClient.js';
+
+const router = express.Router();
+
+const TEMP_DIR = path.join(process.cwd(), 'tmp_scans');
+const tempScans = new Map();
+fs.mkdir(TEMP_DIR, { recursive: true }).catch(console.error);
+
+setInterval(async () => {
+    const now = Date.now();
+    for (const [tempId, data] of tempScans.entries()) {
+        if (now - data.timestamp > 30 * 60 * 1000) {
+            try { await fs.unlink(data.filepath); } catch (e) {}
+            tempScans.delete(tempId);
+        }
+    }
+}, 5 * 60 * 1000);
+
+const cache = {
+    feed_page_1:         { data: null, expires: 0 },
+    leaderboard_all:     { data: null, expires: 0 },
+    leaderboard_session: { data: null, expires: 0 },
+    leaderboard_grade:   { data: null, expires: 0 },
+    challenges_active:   { data: null, expires: 0 }
+};
+const CACHE_TTL = 60 * 1000;
+
+function invalidateCaches(type) {
+    if (type === 'feed') {
+        cache.feed_page_1.expires = 0;
+        cache.feed_page_1.data = null;
+    }
+    if (type === 'leaderboard') {
+        cache.leaderboard_all.expires = 0;     cache.leaderboard_all.data = null;
+        cache.leaderboard_session.expires = 0; cache.leaderboard_session.data = null;
+        cache.leaderboard_grade.expires = 0;   cache.leaderboard_grade.data = null;
+    }
+    if (type === 'challenges') {
+        cache.challenges_active.expires = 0;   cache.challenges_active.data = null;
+    }
+}
+
+const BASE_RULES = `
+## SCORING PHILOSOPHY:
+- Normal selfie: 600-1,100
+- Solid fit check: 1,100-2,200
+- Great outfit + confidence: 2,000-4,000
+- Elite rizz: 2,000-5,000
+- Legendary: 5,000-15,000
+- Minor detail: ±50-300 | Mid factor: ±200-800 | Core factor: ±500-2,500
+
+Output ONLY a JSON object with exactly:
+- "score": integer (exact sum of all gains minus all losses)
+- "analysis_markdown": string formatted exactly as:
+## 🟢 Aura Gained
+* **[Element]**: +[Points] ([Funny reason])
+## 🔴 Aura Lost
+* **[Element]**: -[Points] ([Honest reason])
+## 💬 The Verdict
+[One sharp sentence]
+## 🎯 The Play
+[One specific tip]
+`;
+
+const AURA_PROMPT_STANDALONE = `You are Aura Cat 🕶️🐈, the ultimate judge of social cachet. Evaluate the provided image absolutely. ${BASE_RULES}`;
+const AURA_PROMPT_CONTEXTUAL = `You are Aura Cat 🕶️🐈, the ultimate judge of social cachet.
+You are evaluating a submission to a Challenge or Thread.
+Image 1: The Reference Image
+Image 2: The Submission
+Evaluate Image 2 strictly based on how well it matched the vibe and quality of Image 1. ${BASE_RULES}`;
+
+// ─── POST /initialize ──────────────────────────────────────────────────────────
+router.post('/initialize', async (req, res) => {
+    try {
+        const { device_id, push_token, username, avatar } = req.body;
+        if (!device_id) return res.status(400).json({ success: false, error: 'device_id required' });
+
+        const updateData = { last_login_at: new Date().toISOString() };
+        if (push_token) updateData.push_token = push_token;
+        if (username) updateData.username = username;
+        if (avatar) updateData.avatar = avatar;
+
+        const { data, error } = await supabase
+            .from('aura_profiles')
+            .upsert({ device_id, ...updateData }, { onConflict: 'device_id' })
+            .select('id, username, avatar, current_grade, cumulative_aura')
+            .single();
+
+        if (error) throw error;
+        res.json({ success: true, profile: data });
+    } catch (err) {
+        console.error('[Initialize] Error:', err);
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+
+// ─── POST /analyze ─────────────────────────────────────────────────────────────
+router.post('/analyze', async (req, res) => {
+    try {
+        const {
+            device_id, username, avatar, media_base64,
+            context_type = 'standalone', context_id = null, reference_data = null
+        } = req.body;
+
+        if (!media_base64 || !device_id) {
+            return res.status(400).json({ success: false, error: 'Missing media or device_id.' });
+        }
+
+        const { data: profile, error: profileError } = await supabase
+            .from('aura_profiles')
+            .upsert({ device_id, username, avatar, last_login_at: new Date().toISOString() }, { onConflict: 'device_id' })
+            .select('id')
+            .single();
+
+        if (profileError) throw profileError;
+        console.log('[Analyze] Profile ID:', profile.id);
+
+        let systemPrompt = AURA_PROMPT_STANDALONE;
+        let promptText = 'Analyze this image and calculate my Aura. Return JSON.';
+        let imagesToProcess = [media_base64];
+
+        if ((context_type === 'challenge' || context_type === 'thread') && reference_data) {
+            systemPrompt = AURA_PROMPT_CONTEXTUAL;
+            promptText = `CONTEXT TITLE: ${reference_data.title}\nCONTEXT DESCRIPTION: ${reference_data.description}\nEvaluate Image 2 against Image 1.`;
+            imagesToProcess = [reference_data.image_base64, media_base64];
+        }
+
+        console.log('[Analyze] Running AI...');
+        const aiResult = await generateCompletion({
+            model: 'qwen-vl-max',
+            prompt: promptText,
+            system_prompt: systemPrompt,
+            images: imagesToProcess
+        });
+
+        if (!aiResult.success) throw new Error(aiResult.error);
+
+        const cleanJsonStr = aiResult.data.replace(/```json/gi, '').replace(/```/gi, '').trim();
+        let parsedData;
+        try {
+            parsedData = JSON.parse(cleanJsonStr);
+        } catch {
+            throw new Error(`AI returned invalid JSON: ${cleanJsonStr.substring(0, 100)}`);
+        }
+
+        if (typeof parsedData.score !== 'number') {
+            throw new Error('AI response missing valid score field.');
+        }
+
+        console.log('[Analyze] AI done. Score:', parsedData.score);
+
+        const tempId = crypto.randomUUID();
+        const imageBuffer = Buffer.from(media_base64, 'base64');
+
+        tempScans.set(tempId, {
+            filepath: path.join(TEMP_DIR, `${tempId}.jpg`),
+            timestamp: Date.now(),
+            user_id: profile.id,
+            session_id: null,
+            score: parsedData.score,
+            analysis: parsedData.analysis_markdown,
+            context_type,
+            context_id,
+            ready: false,
+        });
+
+        res.json({
+            success: true,
+            score: parsedData.score,
+            analysis: parsedData.analysis_markdown,
+            temp_scan_id: tempId,
+            profile_id: profile.id,
+        });
+
+        console.log('[Analyze] Response sent. Running async DB writes...');
+
+        (async () => {
+            try {
+                await fs.writeFile(path.join(TEMP_DIR, `${tempId}.jpg`), imageBuffer);
+
+                let { data: session } = await supabase
+                    .from('aura_sessions')
+                    .select('id')
+                    .eq('is_active', true)
+                    .maybeSingle();
+
+                if (!session) {
+                    const start = new Date();
+                    const end = new Date(start.getTime() + (3 * 24 * 60 * 60 * 1000));
+                    const { data: newSession, error: sessionError } = await supabase
+                        .from('aura_sessions')
+                        .insert({ start_time: start, end_time: end, is_active: true })
+                        .select('id')
+                        .single();
+                    if (sessionError) throw sessionError;
+                    session = newSession;
+                }
+
+                const { error: rpcError } = await supabase.rpc('aura_increment_points', {
+                    p_user_id: profile.id,
+                    p_session_id: session.id,
+                    p_score_to_add: parsedData.score,
+                    p_is_challenge: context_type === 'challenge'
+                });
+                if (rpcError) throw rpcError;
+
+                const { data: updatedProfile } = await supabase
+                    .from('aura_profiles')
+                    .select('cumulative_aura, current_grade')
+                    .eq('id', profile.id)
+                    .single();
+
+                const existing = tempScans.get(tempId);
+                if (existing) {
+                    tempScans.set(tempId, {
+                        ...existing,
+                        session_id: session.id,
+                        ready: true,
+                        cumulative_aura: updatedProfile?.cumulative_aura ?? 0,
+                        current_grade: updatedProfile?.current_grade ?? 'Ungraded',
+                    });
+                }
+
+                invalidateCaches('leaderboard');
+                console.log('[Analyze] Async writes complete for', tempId);
+            } catch (asyncErr) {
+                console.error('[Analyze] Async write error:', asyncErr);
+                const existing = tempScans.get(tempId);
+                if (existing) tempScans.set(tempId, { ...existing, ready: true, db_error: true });
+            }
+        })();
+
+    } catch (err) {
+        console.error('[Analyze] Error:', err);
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
+
+// ─── POST /publish ─────────────────────────────────────────────────────────────
+router.post('/publish', async (req, res) => {
+    try {
+        const { temp_scan_id } = req.body;
+
+        if (!temp_scan_id || !tempScans.has(temp_scan_id)) {
+            return res.status(400).json({ success: false, error: 'Scan expired or not found.' });
+        }
+
+        const scanData = await new Promise((resolve, reject) => {
+            const entry = tempScans.get(temp_scan_id);
+            if (entry.ready) return resolve(entry);
+            let waited = 0;
+            const interval = setInterval(() => {
+                const current = tempScans.get(temp_scan_id);
+                waited += 200;
+                if (!current) { clearInterval(interval); reject(new Error('Scan disappeared.')); }
+                else if (current.ready) { clearInterval(interval); resolve(current); }
+                else if (waited >= 10000) { clearInterval(interval); reject(new Error('Timed out waiting for scan.')); }
+            }, 200);
+        });
+
+        if (scanData.db_error || !scanData.user_id) {
+            return res.status(500).json({ success: false, error: 'Score was saved but publish failed due to a database error.' });
+        }
+
+        const fileName = `${scanData.user_id}/${Date.now()}_${temp_scan_id}.jpg`;
+        const fileBuffer = await fs.readFile(scanData.filepath);
+
+        const { error: uploadError } = await supabase.storage
+            .from('aura_media')
+            .upload(fileName, fileBuffer, { contentType: 'image/jpeg' });
+        if (uploadError) throw uploadError;
+
+        const { data: publicUrlData } = supabase.storage.from('aura_media').getPublicUrl(fileName);
+
+        const { error: insertError } = await supabase.from('aura_public_scans').insert({
+            user_id: scanData.user_id,
+            session_id: scanData.session_id,
+            image_url: publicUrlData.publicUrl,
+            score: scanData.score,
+            analysis_json: scanData.analysis,
+            context_type: scanData.context_type,
+            context_id: scanData.context_id
+        });
+        if (insertError) throw insertError;
+
+        await fs.unlink(scanData.filepath).catch(() => {});
+        tempScans.delete(temp_scan_id);
+        invalidateCaches('feed');
+
+        res.json({
+            success: true,
+            message: 'Published.',
+            cumulative_aura: scanData.cumulative_aura,
+            current_grade: scanData.current_grade,
+        });
+
+    } catch (err) {
+        console.error('[Publish] Error:', err);
+        res.status(500).json({ success: false, error: err.message });
+    }
+});
 
 // ─── GET /feed ─────────────────────────────────────────────────────────────────
 router.get('/feed', async (req, res) => {