samarthya-bot 1.0.2

package/backend/controllers/screenController.js

@@ -0,0 +1,91 @@
+const llmService = require('../services/llm/llmService');
+const securityService = require('../services/security/securityService');
+const AuditLog = require('../models/AuditLog');
+
+/**
+ * Analyze a screenshot via Gemini Vision
+ * POST /api/screen/analyze
+ * Body: { image: base64string, prompt?: string }
+ */
+exports.analyzeScreen = async (req, res) => {
+    try {
+        const { image, prompt } = req.body;
+
+        if (!image) {
+            return res.status(400).json({ error: 'Screenshot image required (base64)' });
+        }
+
+        // Remove data URL prefix if present
+        let base64Image = image;
+        if (base64Image.startsWith('data:image')) {
+            base64Image = base64Image.split(',')[1];
+        }
+
+        // Size check (max ~10MB base64)
+        if (base64Image.length > 14_000_000) {
+            return res.status(400).json({ error: 'Image too large. Max 10MB.' });
+        }
+
+        const user = req.user;
+
+        // Audit log
+        await AuditLog.create({
+            userId: user._id,
+            action: 'Screen analysis requested',
+            category: 'browser',
+            details: {
+                toolName: 'screen_understanding',
+                prompt: prompt || 'Auto-analyze',
+                imageSize: `${Math.round(base64Image.length / 1024)}KB`,
+                riskLevel: 'medium'
+            },
+            status: 'success',
+            riskLevel: 'medium'
+        });
+
+        // Call Gemini Vision
+        const analysis = await llmService.analyzeScreen(
+            base64Image,
+            prompt || 'Analyze this screenshot. Identify what app/website this is, what the user is trying to do, and suggest the next steps.',
+            user
+        );
+
+        // Mask any sensitive data in the analysis
+        analysis.content = securityService.maskSensitiveData(analysis.content);
+
+        res.json({
+            success: true,
+            analysis: {
+                content: analysis.content,
+                model: analysis.model,
+                tokensUsed: analysis.tokensUsed || 0
+            }
+        });
+
+    } catch (error) {
+        console.error('Screen analyze error:', error);
+        res.status(500).json({
+            error: 'Screen analysis failed',
+            message: error.message
+        });
+    }
+};
+
+/**
+ * List supported screen types this AI can understand
+ * GET /api/screen/supported
+ */
+exports.getSupportedScreens = (req, res) => {
+    res.json({
+        supported: [
+            { id: 'irctc', name: 'IRCTC', nameHi: 'आईआरसीटीसी', desc: 'Train booking, PNR status, tatkal' },
+            { id: 'gst', name: 'GST Portal', nameHi: 'जीएसटी पोर्टल', desc: 'GSTR filing, returns, challan' },
+            { id: 'digilocker', name: 'DigiLocker', nameHi: 'डिजीलॉकर', desc: 'Document download, Aadhaar, PAN' },
+            { id: 'upi', name: 'UPI Apps', nameHi: 'यूपीआई ऐप्स', desc: 'GPay, PhonePe, Paytm transactions' },
+            { id: 'banking', name: 'Net Banking', nameHi: 'नेट बैंकिंग', desc: 'Balance check, transfers, statements' },
+            { id: 'ecommerce', name: 'E-Commerce', nameHi: 'ई-कॉमर्स', desc: 'Amazon, Flipkart orders & tracking' },
+            { id: 'govt', name: 'Govt Portals', nameHi: 'सरकारी पोर्टल', desc: 'Income tax, passport, PF' },
+            { id: 'any', name: 'Any Website', nameHi: 'कोई भी वेबसाइट', desc: 'General form filling assistance' },
+        ]
+    });
+};

package/backend/controllers/telegramController.js

@@ -0,0 +1,120 @@
+const telegramService = require('../services/telegram/telegramService');
+const llmService = require('../services/llm/llmService');
+const securityService = require('../services/security/securityService');
+const plannerService = require('../services/planner/plannerService');
+const User = require('../models/User');
+const Conversation = require('../models/Conversation');
+const Memory = require('../models/Memory');
+
+/**
+ * Handle incoming Telegram messages (POST webhook)
+ */
+exports.handleMessage = async (req, res) => {
+    // Always respond 200 OK fast
+    res.status(200).send('OK');
+
+    try {
+        const update = req.body;
+        // Check if message and text exist
+        if (!update.message || !update.message.text) return;
+
+        const chatId = update.message.chat.id;
+        const text = update.message.text;
+        const fromName = update.message.from?.first_name || 'User';
+        const username = update.message.from?.username || chatId;
+
+        console.log(`📱 Telegram from ${fromName} (${chatId}): ${text.substring(0, 50)}`);
+
+        // Find or create user by chatId
+        let user = await User.findOne({ email: `tg_${chatId}@samarthya.local` });
+        if (!user) {
+            user = await User.create({
+                name: fromName,
+                email: `tg_${chatId}@samarthya.local`,
+                password: 'telegram_user',
+                language: 'hinglish',
+                workType: 'personal',
+                activePack: 'personal',
+                source: 'telegram'
+            });
+
+            // Welcome message for new Telegram users
+            await telegramService.sendMessage(chatId,
+                '🙏 Namaste! Main *SamarthyaBot* hoon.\n\n' +
+                'Main aapka personal AI assistant hoon.\n\n' +
+                '💡 Try karo:\n' +
+                '• "Bhai, 5 log ka movie ticket ka bill split karo"\n' +
+                '• "Kal meeting create karo"\n' +
+                '• "Summarize this long text..."\n\n' +
+                '🔐 Aapka data yahan puri tarah safe hai.'
+            );
+            return;
+        }
+
+        // Security check
+        const securityReport = securityService.scanForSensitiveData(text);
+        if (securityReport.found) {
+            await telegramService.sendMessage(chatId,
+                `⚠️ *Sensitive Data Detected*: ${securityReport.types.join(', ')}\n` +
+                'Maine automatically isko mask kar diya hai.'
+            );
+        }
+
+        // Context (Memories)
+        const memories = await Memory.find({ userId: user._id })
+            .sort({ importance: -1 })
+            .limit(10)
+            .lean();
+
+        // Previous Conversation
+        let conversation = await Conversation.findOne({
+            userId: user._id,
+            source: 'telegram',
+            updatedAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) }
+        }).sort({ updatedAt: -1 });
+
+        const previousMessages = conversation?.messages?.slice(-6)?.map(m => ({
+            role: m.role,
+            content: m.content
+        })) || [];
+
+        // Progress handler
+        const onProgress = async (updateText) => {
+            // Send the agent's thought/plan as an intermediate message
+            if (updateText && updateText.trim().length > 0) {
+                await telegramService.sendMessage(chatId, `🧠 *Agent Progress:*${updateText}`);
+            }
+        };
+
+        // Process through the full Agentic Planner (OS Tools, Web, Mem)
+        const result = await plannerService.processMessage(user, previousMessages, text, onProgress);
+
+        let replyText = result.response;
+        // Truncate if too large (~4096 limit in Telegram)
+        if (replyText.length > 4000) {
+            replyText = replyText.substring(0, 3990) + '\n\n... (truncated)';
+        }
+
+        await telegramService.sendMessage(chatId, replyText);
+
+        // Save conversation
+        if (!conversation) {
+            conversation = new Conversation({ userId: user._id, title: text.substring(0, 20), source: 'telegram', messages: [] });
+        }
+        conversation.messages.push({ role: 'user', content: text });
+        conversation.messages.push({
+            role: 'assistant',
+            content: result.response,
+            toolCalls: result.toolCalls,
+            language: result.language,
+            metadata: {
+                tokensUsed: result.tokensUsed,
+                model: result.model
+            }
+        });
+        await conversation.save();
+
+    } catch (error) {
+        console.error('Telegram handler error:', error);
+    }
+};

package/backend/controllers/toolsController.js

@@ -0,0 +1,56 @@
+const toolRegistry = require('../services/tools/toolRegistry');
+const { TOOL_PACKS } = require('../config/constants');
+
+// Get all available tools
+exports.getTools = async (req, res) => {
+    try {
+        const tools = toolRegistry.getAllTools().map(t => ({
+            name: t.name,
+            description: t.description,
+            descriptionHi: t.descriptionHi,
+            riskLevel: t.riskLevel,
+            category: t.category,
+            parameters: t.parameters
+        }));
+
+        res.json({ success: true, tools });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Get tool packs
+exports.getToolPacks = async (req, res) => {
+    try {
+        const packs = Object.entries(TOOL_PACKS).map(([key, pack]) => ({
+            id: key,
+            name: pack.name,
+            nameHi: pack.nameHi,
+            description: pack.description,
+            toolCount: pack.tools.length,
+            tools: pack.tools
+        }));
+
+        res.json({ success: true, packs });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Get tools for a specific pack
+exports.getPackTools = async (req, res) => {
+    try {
+        const { packId } = req.params;
+        const tools = toolRegistry.getToolsForPack(packId).map(t => ({
+            name: t.name,
+            description: t.description,
+            descriptionHi: t.descriptionHi,
+            riskLevel: t.riskLevel,
+            category: t.category
+        }));
+
+        res.json({ success: true, tools, pack: TOOL_PACKS[packId] });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};

package/backend/controllers/whatsappController.js

@@ -0,0 +1,214 @@
+const whatsappService = require('../services/whatsapp/whatsappService');
+const llmService = require('../services/llm/llmService');
+const securityService = require('../services/security/securityService');
+const User = require('../models/User');
+const Conversation = require('../models/Conversation');
+const Memory = require('../models/Memory');
+
+/**
+ * WhatsApp Webhook Verification (GET)
+ * Meta sends this to verify your webhook URL
+ */
+exports.verifyWebhook = (req, res) => {
+    const mode = req.query['hub.mode'];
+    const token = req.query['hub.verify_token'];
+    const challenge = req.query['hub.challenge'];
+
+    if (mode === 'subscribe' && token === whatsappService.verifyToken) {
+        console.log('✅ WhatsApp webhook verified');
+        return res.status(200).send(challenge);
+    }
+
+    console.error('❌ WhatsApp webhook verification failed');
+    return res.status(403).send('Forbidden');
+};
+
+/**
+ * WhatsApp Incoming Message Handler (POST)
+ * Processes incoming messages and sends AI responses
+ */
+exports.handleMessage = async (req, res) => {
+    // Always respond 200 quickly (WhatsApp requires fast ACK)
+    res.status(200).send('EVENT_RECEIVED');
+
+    try {
+        const parsed = whatsappService.parseWebhookMessage(req.body);
+        if (!parsed) return;
+
+        console.log(`📱 WhatsApp from ${parsed.contactName} (${parsed.from}): ${parsed.text || parsed.type}`);
+
+        // Mark as read
+        await whatsappService.markAsRead(parsed.messageId);
+
+        // Find or create user by phone
+        let user = await User.findOne({ phone: parsed.from });
+        if (!user) {
+            user = await User.create({
+                name: parsed.contactName,
+                phone: parsed.from,
+                email: `wa_${parsed.from}@samarthya.local`,
+                password: 'whatsapp_user',
+                language: 'hinglish',
+                workType: 'personal',
+                activePack: 'personal',
+                source: 'whatsapp'
+            });
+
+            // Welcome message for new WhatsApp users
+            await whatsappService.sendMessage(parsed.from,
+                '🙏 Namaste! Main SamarthyaBot hoon.\n\n' +
+                'Main aapka personal AI assistant hoon. Hindi, Hinglish ya English mein baat karo!\n\n' +
+                '💡 Try karo:\n' +
+                '• "GST ki deadline kab hai?"\n' +
+                '• "500 * 18% calculate karo"\n' +
+                '• "Reminder set karo"\n' +
+                '• Screenshot bhejo — main samajh lunga!\n\n' +
+                '🔐 Aapka data safe hai. PAN/Aadhaar auto-mask hota hai.'
+            );
+            return;
+        }
+
+        // Handle image messages → Screen Understanding
+        if (parsed.type === 'image' && parsed.mediaId) {
+            await handleScreenshot(parsed, user);
+            return;
+        }
+
+        // Handle text messages → AI pipeline
+        if (parsed.text) {
+            await handleTextMessage(parsed, user);
+            return;
+        }
+
+        // Handle audio → notify not supported yet
+        if (parsed.type === 'audio') {
+            await whatsappService.sendMessage(parsed.from,
+                '🎤 Voice notes ka support jald aa raha hai! Abhi ke liye text mein likho ya screenshot bhejo.'
+            );
+        }
+
+    } catch (error) {
+        console.error('WhatsApp handler error:', error);
+    }
+};
+
+/**
+ * Process text messages through AI pipeline
+ */
+async function handleTextMessage(parsed, user) {
+    try {
+        // Security scan
+        const securityReport = securityService.scanForSensitiveData(parsed.text);
+        if (securityReport.found) {
+            await whatsappService.sendMessage(parsed.from,
+                `⚠️ Sensitive data detected: ${securityReport.types.join(', ')}\n` +
+                '🔐 Main isko mask kar dunga. Dhyan rakhein!'
+            );
+        }
+
+        // Get user memories for context
+        const memories = await Memory.find({ userId: user._id })
+            .sort({ importance: -1 })
+            .limit(10)
+            .lean();
+
+        // Get/create conversation
+        let conversation = await Conversation.findOne({
+            userId: user._id,
+            source: 'whatsapp',
+            updatedAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) } // last 24h
+        }).sort({ updatedAt: -1 });
+
+        const previousMessages = conversation?.messages?.slice(-6)?.map(m => ({
+            role: m.role,
+            content: m.content
+        })) || [];
+
+        // Build prompt and call LLM
+        const systemPrompt = llmService.buildSystemPrompt(user, [], memories);
+        const messages = [
+            ...previousMessages,
+            { role: 'user', content: parsed.text }
+        ];
+
+        const response = await llmService.chat(messages, systemPrompt, user);
+
+        // Truncate for WhatsApp (4096 char limit)
+        let replyText = response.content;
+        if (replyText.length > 4000) {
+            replyText = replyText.substring(0, 3990) + '\n\n... (truncated)';
+        }
+
+        // Mask sensitive data in response
+        replyText = securityService.maskSensitiveData(replyText);
+
+        // Save conversation
+        if (!conversation) {
+            conversation = await Conversation.create({
+                userId: user._id,
+                title: parsed.text.substring(0, 50),
+                source: 'whatsapp',
+                messages: []
+            });
+        }
+
+        conversation.messages.push(
+            { role: 'user', content: parsed.text },
+            { role: 'assistant', content: replyText }
+        );
+        await conversation.save();
+
+        // Send reply
+        await whatsappService.sendMessage(parsed.from, replyText);
+
+    } catch (error) {
+        console.error('Text message handler error:', error);
+        await whatsappService.sendMessage(parsed.from,
+            '❌ Kuch error aa gaya. Thodi der baad try karo.'
+        );
+    }
+}
+
+/**
+ * Handle screenshot messages → Gemini Vision (Screen Understanding)
+ */
+async function handleScreenshot(parsed, user) {
+    try {
+        await whatsappService.sendMessage(parsed.from,
+            '👁️ Screenshot received! Analyzing...'
+        );
+
+        // Download image from WhatsApp
+        const media = await whatsappService.downloadMedia(parsed.mediaId);
+        if (!media) {
+            await whatsappService.sendMessage(parsed.from,
+                '❌ Image download fail ho gaya. Dubara bhejo.'
+            );
+            return;
+        }
+
+        // Convert to base64 for Gemini Vision
+        const base64Image = media.buffer.toString('base64');
+        const prompt = parsed.caption ||
+            'Is screenshot mein kya hai? Mujhe batao aur next step suggest karo.';
+
+        // Call Gemini Vision
+        const analysis = await llmService.analyzeScreen(base64Image, prompt, user);
+
+        // Truncate for WhatsApp
+        let replyText = analysis.content;
+        if (replyText.length > 4000) {
+            replyText = replyText.substring(0, 3990) + '\n\n... (truncated)';
+        }
+
+        replyText = securityService.maskSensitiveData(replyText);
+
+        await whatsappService.sendMessage(parsed.from, replyText);
+
+    } catch (error) {
+        console.error('Screenshot handler error:', error);
+        await whatsappService.sendMessage(parsed.from,
+            '❌ Screen analysis mein error aa gaya. Check karo ki Gemini API key set hai .env mein.'
+        );
+    }
+}

package/backend/fix_toolRegistry.js

@@ -0,0 +1,25 @@
+const fs = require('fs');
+
+let content = fs.readFileSync('services/tools/toolRegistry.js', 'utf8');
+
+// 1. Replace SAFE_DIR definition
+content = content.replace(
+    /const SAFE_DIR = path\.join\(os\.homedir\(\), 'SamarthyaBot_Files'\);\n\n\/\/ Ensure safe directory exists on startup\n\(\(async \(\) => {\n    try { await fs\.mkdir\(SAFE_DIR, { recursive: true } \); } catch \(e\) { \/\* ignore \*\/ }\n}\)\(\);/g,
+    `const BASE_DIR = path.join(os.homedir(), 'SamarthyaBot_Files');\n\nasync function getSafeDir(user) {\n    let dir = BASE_DIR;\n    if (user && (user._id || user.id)) {\n        dir = path.join(BASE_DIR, String(user._id || user.id));\n    }\n    try { await fs.mkdir(dir, { recursive: true }); } catch(e) {}\n    return dir;\n}`
+);
+
+// 2. update execute function signatures specifically
+content = content.replace(/execute: async \(args\) => {/g, 'execute: async (args, userContext) => {');
+content = content.replace(/execute: async \(\) => {/g, 'execute: async (args, userContext) => {');
+
+// 3. inject SAFE_DIR into the functions that need it
+const fileFuncs = ['file_read', 'file_write', 'file_list', 'note_take', 'reminder_set', 'reminders_get', 'gst_reminder', 'calendar_schedule'];
+content = content.replace(/execute: async \(args, userContext\) => {\n            try {/g, 
+    'execute: async (args, userContext) => {\n            try {\n                const SAFE_DIR = await getSafeDir(userContext);');
+
+// 4. Update executeTool and execute calls
+content = content.replace(/async executeTool\(name, args\) {/g, 'async executeTool(name, args, user) {');
+content = content.replace(/const result = await tool\.execute\(args\);/g, 'const result = await tool.execute(args, user);');
+
+fs.writeFileSync('services/tools/toolRegistry.js', content);
+console.log('Fixed toolRegistry.js');

package/backend/middleware/auth.js

@@ -0,0 +1,28 @@
+const User = require('../models/User');
+
+const auth = async (req, res, next) => {
+    try {
+        // Local OS Mode: Bypass JWT Authentication 
+        // We automatically find or create a default "Local Admin" user.
+        let user = await User.findOne({ email: 'admin@samarthya.local' });
+
+        if (!user) {
+            user = new User({
+                name: 'System Admin',
+                email: 'admin@samarthya.local',
+                password: 'no_password_needed_for_local',
+                role: 'admin',
+                activePack: 'developer'
+            });
+            await user.save();
+        }
+
+        req.user = user;
+        next();
+    } catch (error) {
+        console.error("Auth Middleware Error:", error);
+        res.status(500).json({ success: false, message: 'Local Auth Error', error: error.message });
+    }
+};
+
+module.exports = auth;

package/backend/models/AuditLog.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose');
+
+const auditLogSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+    conversationId: { type: mongoose.Schema.Types.ObjectId, ref: 'Conversation' },
+    action: { type: String, required: true },
+    category: {
+        type: String,
+        enum: ['file', 'email', 'browser', 'calendar', 'search', 'system', 'security', 'tool'],
+        required: true
+    },
+    details: {
+        toolName: String,
+        input: mongoose.Schema.Types.Mixed,
+        output: mongoose.Schema.Types.Mixed,
+        riskLevel: { type: String, enum: ['low', 'medium', 'high', 'critical'], default: 'low' },
+        sensitiveDataFound: [String],
+        permissionGranted: Boolean
+    },
+    status: { type: String, enum: ['success', 'failed', 'blocked', 'rolled_back'], default: 'success' },
+    rollbackData: mongoose.Schema.Types.Mixed,
+    canRollback: { type: Boolean, default: false }
+}, { timestamps: true });
+
+auditLogSchema.index({ userId: 1, createdAt: -1 });
+auditLogSchema.index({ category: 1 });
+
+module.exports = mongoose.model('AuditLog', auditLogSchema);

package/backend/models/BackgroundJob.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const backgroundJobSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+    taskName: { type: String, required: true },
+    prompt: { type: String, required: true },
+    intervalMinutes: { type: Number, required: true }, // 0 means run once
+    lastRunAt: { type: Date },
+    nextRunAt: { type: Date, required: true },
+    isActive: { type: Boolean, default: true },
+});
+
+module.exports = mongoose.model('BackgroundJob', backgroundJobSchema);

package/backend/models/Conversation.js

@@ -0,0 +1,40 @@
+const mongoose = require('mongoose');
+
+const messageSchema = new mongoose.Schema({
+    role: { type: String, enum: ['user', 'assistant', 'system', 'tool'], required: true },
+    content: { type: String, required: true },
+    language: { type: String, enum: ['hindi', 'hinglish', 'english'], default: 'english' },
+    toolCalls: [{
+        toolName: String,
+        arguments: mongoose.Schema.Types.Mixed,
+        result: mongoose.Schema.Types.Mixed,
+        status: { type: String, enum: ['pending', 'running', 'completed', 'failed', 'blocked'], default: 'pending' },
+        riskLevel: { type: String, enum: ['low', 'medium', 'high', 'critical'], default: 'low' },
+        notificationParams: mongoose.Schema.Types.Mixed,
+        executedAt: Date
+    }],
+    metadata: {
+        tokensUsed: Number,
+        responseTime: Number,
+        model: String,
+        sensitiveDataDetected: [String]
+    }
+}, { timestamps: true });
+
+const conversationSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+    title: { type: String, default: 'New Conversation' },
+    messages: [messageSchema],
+    context: {
+        activePack: String,
+        language: String,
+        taskType: String
+    },
+    isActive: { type: Boolean, default: true },
+    isPinned: { type: Boolean, default: false },
+    source: { type: String, enum: ['web', 'whatsapp', 'telegram'], default: 'web' }
+}, { timestamps: true });
+
+conversationSchema.index({ userId: 1, updatedAt: -1 });
+
+module.exports = mongoose.model('Conversation', conversationSchema);

package/backend/models/Memory.js

@@ -0,0 +1,17 @@
+const mongoose = require('mongoose');
+
+const memorySchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+    type: { type: String, enum: ['preference', 'fact', 'task', 'context', 'reminder'], required: true },
+    key: { type: String, required: true },
+    value: { type: mongoose.Schema.Types.Mixed, required: true },
+    importance: { type: Number, default: 5, min: 1, max: 10 },
+    expiresAt: Date,
+    source: { type: String, default: 'conversation' },
+    tags: [String]
+}, { timestamps: true });
+
+memorySchema.index({ userId: 1, type: 1 });
+memorySchema.index({ userId: 1, key: 1 }, { unique: true });
+
+module.exports = mongoose.model('Memory', memorySchema);

package/backend/models/User.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    email: { type: String, required: true, unique: true },
+    password: { type: String, required: true },
+    language: { type: String, enum: ['hindi', 'hinglish', 'english'], default: 'hinglish' },
+    city: { type: String, default: '' },
+    timezone: { type: String, default: 'Asia/Kolkata' },
+    workType: { type: String, enum: ['student', 'business', 'developer', 'personal', 'other'], default: 'personal' },
+    activePack: { type: String, enum: ['student', 'business', 'developer', 'personal'], default: 'personal' },
+    permissions: {
+        fileAccess: { type: String, enum: ['allow_once', 'allow_always', 'never', 'ask'], default: 'ask' },
+        emailAccess: { type: String, enum: ['allow_once', 'allow_always', 'never', 'ask'], default: 'ask' },
+        browserAccess: { type: String, enum: ['allow_once', 'allow_always', 'never', 'ask'], default: 'ask' },
+        calendarAccess: { type: String, enum: ['allow_once', 'allow_always', 'never', 'ask'], default: 'ask' },
+    },
+    avatar: { type: String, default: '' },
+    phone: { type: String, default: '', index: true },
+    source: { type: String, enum: ['web', 'whatsapp', 'telegram'], default: 'web' },
+    isActive: { type: Boolean, default: true }
+}, { timestamps: true });
+
+module.exports = mongoose.model('User', userSchema);