samarthya-bot 1.0.2

package/backend/controllers/authController.js

@@ -0,0 +1,154 @@
+const User = require('../models/User');
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+
+// Register
+exports.register = async (req, res) => {
+    try {
+        const { name, email, password, language, city, workType } = req.body;
+
+        const exists = await User.findOne({ email });
+        if (exists) {
+            return res.status(400).json({ success: false, message: 'Email already registered' });
+        }
+
+        const salt = await bcrypt.genSalt(10);
+        const hashed = await bcrypt.hash(password, salt);
+
+        const user = await User.create({
+            name,
+            email,
+            password: hashed,
+            language: language || 'hinglish',
+            city: city || '',
+            workType: workType || 'personal',
+            activePack: workType || 'personal'
+        });
+
+        const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '30d' });
+
+        res.status(201).json({
+            success: true,
+            token,
+            user: {
+                id: user._id,
+                name: user.name,
+                email: user.email,
+                language: user.language,
+                city: user.city,
+                workType: user.workType,
+                activePack: user.activePack,
+                permissions: user.permissions
+            }
+        });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Login
+exports.login = async (req, res) => {
+    try {
+        const { email, password } = req.body;
+
+        const user = await User.findOne({ email });
+        if (!user) {
+            return res.status(401).json({ success: false, message: 'Invalid credentials' });
+        }
+
+        const isMatch = await bcrypt.compare(password, user.password);
+        if (!isMatch) {
+            return res.status(401).json({ success: false, message: 'Invalid credentials' });
+        }
+
+        const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '30d' });
+
+        res.json({
+            success: true,
+            token,
+            user: {
+                id: user._id,
+                name: user.name,
+                email: user.email,
+                language: user.language,
+                city: user.city,
+                workType: user.workType,
+                activePack: user.activePack,
+                permissions: user.permissions
+            }
+        });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Get Profile
+exports.getProfile = async (req, res) => {
+    try {
+        const user = await User.findById(req.user.id).select('-password');
+        if (!user) return res.status(404).json({ success: false, message: 'User not found' });
+        res.json({ success: true, user });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Update Profile
+exports.updateProfile = async (req, res) => {
+    try {
+        const { name, language, city, workType, activePack, permissions } = req.body;
+
+        const updateData = {};
+        if (name) updateData.name = name;
+        if (language) updateData.language = language;
+        if (city) updateData.city = city;
+        if (workType) updateData.workType = workType;
+        if (activePack) updateData.activePack = activePack;
+        if (permissions) updateData.permissions = permissions;
+
+        const user = await User.findByIdAndUpdate(req.user.id, updateData, { new: true }).select('-password');
+        res.json({ success: true, user });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Quick Demo Login (No password needed - for development)
+exports.demoLogin = async (req, res) => {
+    try {
+        let user = await User.findOne({ email: 'demo@samarthya.com' });
+
+        if (!user) {
+            const salt = await bcrypt.genSalt(10);
+            const hashed = await bcrypt.hash('demo123', salt);
+            user = await User.create({
+                name: 'Demo User',
+                email: 'demo@samarthya.com',
+                password: hashed,
+                language: 'hinglish',
+                city: 'Mumbai',
+                workType: 'personal',
+                activePack: 'personal'
+            });
+        }
+
+        const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '30d' });
+
+        res.json({
+            success: true,
+            token,
+            user: {
+                id: user._id,
+                name: user.name,
+                email: user.email,
+                language: user.language,
+                city: user.city,
+                workType: user.workType,
+                activePack: user.activePack,
+                permissions: user.permissions
+            }
+        });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};

package/backend/controllers/chatController.js

@@ -0,0 +1,158 @@
+const Conversation = require('../models/Conversation');
+const User = require('../models/User');
+const plannerService = require('../services/planner/plannerService');
+const securityService = require('../services/security/securityService');
+
+// Send message and get AI response
+exports.sendMessage = async (req, res) => {
+    try {
+        const { message, conversationId } = req.body;
+        const userId = req.user.id;
+
+        if (!message || !message.trim()) {
+            return res.status(400).json({ success: false, message: 'Message is required' });
+        }
+
+        const user = await User.findById(userId);
+        if (!user) return res.status(404).json({ success: false, message: 'User not found' });
+
+        // Get or create conversation
+        let conversation;
+        if (conversationId) {
+            conversation = await Conversation.findOne({ _id: conversationId, userId });
+            if (!conversation) {
+                return res.status(404).json({ success: false, message: 'Conversation not found' });
+            }
+        } else {
+            conversation = await Conversation.create({
+                userId,
+                title: message.substring(0, 60) + (message.length > 60 ? '...' : ''),
+                messages: [],
+                context: {
+                    activePack: user.activePack,
+                    language: user.language
+                }
+            });
+        }
+
+        // Add user message
+        conversation.messages.push({
+            role: 'user',
+            content: message,
+            language: user.language
+        });
+
+        // Process through planner
+        const conversationHistory = conversation.messages.slice(-20).map(m => ({
+            role: m.role,
+            content: m.content
+        }));
+
+        const result = await plannerService.processMessage(user, conversationHistory, message);
+
+        // Add assistant response
+        conversation.messages.push({
+            role: 'assistant',
+            content: result.response,
+            language: result.language,
+            toolCalls: result.toolCalls,
+            metadata: {
+                tokensUsed: result.tokensUsed,
+                model: result.model,
+                sensitiveDataDetected: result.sensitiveDataWarnings.map(w => w.type)
+            }
+        });
+
+        await conversation.save();
+
+        // Emit via socket if available
+        if (req.io) {
+            req.io.to(userId).emit('message', {
+                conversationId: conversation._id,
+                message: {
+                    role: 'assistant',
+                    content: result.response,
+                    toolCalls: result.toolCalls,
+                    sensitiveDataWarnings: result.sensitiveDataWarnings,
+                    timestamp: new Date()
+                }
+            });
+        }
+
+        res.json({
+            success: true,
+            conversationId: conversation._id,
+            message: {
+                role: 'assistant',
+                content: result.response,
+                toolCalls: result.toolCalls,
+                sensitiveDataWarnings: result.sensitiveDataWarnings,
+                tokensUsed: result.tokensUsed,
+                model: result.model,
+                language: result.language
+            }
+        });
+    } catch (error) {
+        console.error('Chat error:', error);
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Get all conversations
+exports.getConversations = async (req, res) => {
+    try {
+        const conversations = await Conversation.find({ isActive: true })
+            .select('title context isPinned createdAt updatedAt')
+            .sort({ isPinned: -1, updatedAt: -1 })
+            .limit(50);
+
+        res.json({ success: true, conversations });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Get single conversation with messages
+exports.getConversation = async (req, res) => {
+    try {
+        const conversation = await Conversation.findOne({
+            _id: req.params.id
+        });
+
+        if (!conversation) {
+            return res.status(404).json({ success: false, message: 'Conversation not found' });
+        }
+
+        res.json({ success: true, conversation });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Delete conversation
+exports.deleteConversation = async (req, res) => {
+    try {
+        await Conversation.findOneAndUpdate(
+            { _id: req.params.id },
+            { isActive: false }
+        );
+        res.json({ success: true, message: 'Conversation deleted' });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+// Pin/Unpin conversation
+exports.togglePin = async (req, res) => {
+    try {
+        const conv = await Conversation.findOne({ _id: req.params.id });
+        if (!conv) return res.status(404).json({ success: false, message: 'Not found' });
+
+        conv.isPinned = !conv.isPinned;
+        await conv.save();
+
+        res.json({ success: true, isPinned: conv.isPinned });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};

package/backend/controllers/fileController.js

@@ -0,0 +1,268 @@
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BASE_DIR = path.join(os.homedir(), 'SamarthyaBot_Files');
+
+/**
+ * Get user's sandboxed directory
+ */
+function getUserDir(userId) {
+    return path.join(BASE_DIR, String(userId));
+}
+
+/**
+ * Ensure user directory exists
+ */
+async function ensureUserDir(userId) {
+    const userDir = getUserDir(userId);
+    await fs.mkdir(userDir, { recursive: true });
+    // Create default subdirectories
+    await fs.mkdir(path.join(userDir, 'notes'), { recursive: true });
+    await fs.mkdir(path.join(userDir, 'reminders'), { recursive: true });
+    await fs.mkdir(path.join(userDir, 'calendar'), { recursive: true });
+    await fs.mkdir(path.join(userDir, 'downloads'), { recursive: true });
+    return userDir;
+}
+
+/**
+ * Validate path is within user's sandbox
+ */
+function validatePath(userDir, requestedPath) {
+    const resolved = path.resolve(userDir, requestedPath || '');
+    if (!resolved.startsWith(userDir)) {
+        throw new Error('Access denied: Path outside sandbox');
+    }
+    return resolved;
+}
+
+/**
+ * GET /api/files/list — List files and folders
+ */
+exports.listFiles = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+        const subPath = req.query.path || '';
+        const fullPath = validatePath(userDir, subPath);
+
+        const entries = await fs.readdir(fullPath, { withFileTypes: true });
+        const items = [];
+
+        for (const entry of entries) {
+            const entryPath = path.join(fullPath, entry.name);
+            try {
+                const stat = await fs.stat(entryPath);
+                items.push({
+                    name: entry.name,
+                    type: entry.isDirectory() ? 'folder' : 'file',
+                    size: entry.isDirectory() ? null : stat.size,
+                    modified: stat.mtime,
+                    extension: entry.isDirectory() ? null : path.extname(entry.name).slice(1).toLowerCase(),
+                    path: subPath ? `${subPath}/${entry.name}` : entry.name
+                });
+            } catch (e) {
+                // Skip inaccessible
+            }
+        }
+
+        // Sort: folders first, then alphabetical
+        items.sort((a, b) => {
+            if (a.type !== b.type) return a.type === 'folder' ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+
+        res.json({
+            success: true,
+            currentPath: subPath || '/',
+            items,
+            totalItems: items.length
+        });
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};
+
+/**
+ * GET /api/files/read — Read file contents (text only)
+ */
+exports.readFile = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+        const filePath = validatePath(userDir, req.query.path);
+
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            return res.status(400).json({ success: false, error: 'Cannot read a directory' });
+        }
+        if (stat.size > 2 * 1024 * 1024) {
+            return res.status(400).json({ success: false, error: 'File too large (max 2MB for preview)' });
+        }
+
+        const content = await fs.readFile(filePath, 'utf-8');
+        const ext = path.extname(filePath).slice(1).toLowerCase();
+
+        res.json({
+            success: true,
+            name: path.basename(filePath),
+            content,
+            size: stat.size,
+            extension: ext,
+            modified: stat.mtime
+        });
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};
+
+/**
+ * GET /api/files/download — Download a file
+ */
+exports.downloadFile = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+        const filePath = validatePath(userDir, req.query.path);
+
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            return res.status(400).json({ success: false, error: 'Cannot download a directory' });
+        }
+
+        res.download(filePath, path.basename(filePath));
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};
+
+/**
+ * POST /api/files/mkdir — Create a folder
+ */
+exports.createFolder = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+        const { name, parentPath } = req.body;
+
+        if (!name || /[/\\<>:|?*"]/.test(name)) {
+            return res.status(400).json({ success: false, error: 'Invalid folder name' });
+        }
+
+        const folderPath = validatePath(userDir, parentPath ? `${parentPath}/${name}` : name);
+        await fs.mkdir(folderPath, { recursive: true });
+
+        res.json({ success: true, message: `Folder "${name}" created`, path: parentPath ? `${parentPath}/${name}` : name });
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};
+
+/**
+ * DELETE /api/files/delete — Delete a file or empty folder
+ */
+exports.deleteFile = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+        const filePath = validatePath(userDir, req.query.path);
+
+        // Prevent deleting root
+        if (filePath === userDir) {
+            return res.status(400).json({ success: false, error: 'Cannot delete root directory' });
+        }
+
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            await fs.rm(filePath, { recursive: true });
+        } else {
+            await fs.unlink(filePath);
+        }
+
+        res.json({ success: true, message: 'Deleted successfully' });
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};
+
+/**
+ * POST /api/files/upload — Upload a file
+ */
+exports.uploadFile = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+        const { filename, content, parentPath } = req.body;
+
+        if (!filename || !content) {
+            return res.status(400).json({ success: false, error: 'Filename and content required' });
+        }
+
+        const safeName = filename.replace(/[/\\<>:|?*"]/g, '_');
+        const filePath = validatePath(userDir, parentPath ? `${parentPath}/${safeName}` : safeName);
+
+        // Handle base64 content (for binary files)
+        if (content.startsWith('data:')) {
+            const base64Data = content.split(',')[1];
+            await fs.writeFile(filePath, Buffer.from(base64Data, 'base64'));
+        } else {
+            await fs.writeFile(filePath, content, 'utf-8');
+        }
+
+        const stat = await fs.stat(filePath);
+        res.json({
+            success: true,
+            message: `File "${safeName}" uploaded`,
+            size: stat.size,
+            path: parentPath ? `${parentPath}/${safeName}` : safeName
+        });
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};
+
+/**
+ * GET /api/files/stats — Get storage stats
+ */
+exports.getStats = async (req, res) => {
+    try {
+        const userId = req.user._id || req.user.id;
+        const userDir = await ensureUserDir(userId);
+
+        let totalSize = 0;
+        let fileCount = 0;
+        let folderCount = 0;
+
+        async function walk(dir) {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    folderCount++;
+                    await walk(fullPath);
+                } else {
+                    fileCount++;
+                    const stat = await fs.stat(fullPath);
+                    totalSize += stat.size;
+                }
+            }
+        }
+
+        await walk(userDir);
+
+        res.json({
+            success: true,
+            stats: {
+                totalSize,
+                totalSizeFormatted: totalSize < 1024 ? `${totalSize} B` :
+                    totalSize < 1048576 ? `${(totalSize / 1024).toFixed(1)} KB` :
+                        `${(totalSize / 1048576).toFixed(1)} MB`,
+                fileCount,
+                folderCount
+            }
+        });
+    } catch (error) {
+        res.status(400).json({ success: false, error: error.message });
+    }
+};

package/backend/controllers/platformController.js

@@ -0,0 +1,54 @@
+const BackgroundJob = require('../models/BackgroundJob');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const toolRegistry = require('../services/tools/toolRegistry');
+
+exports.getPlatformStatus = async (req, res) => {
+    try {
+        const activeJobs = await BackgroundJob.countDocuments({ isActive: true });
+
+        let pluginsCount = 0;
+        try {
+            const pluginDir = path.join(os.homedir(), 'SamarthyaBot_Files', 'plugins');
+            const files = await fs.readdir(pluginDir);
+            pluginsCount = files.filter(f => f.endsWith('.js')).length;
+        } catch (e) { }
+
+        res.json({
+            success: true,
+            status: {
+                uptime: process.uptime(),
+                totalTools: toolRegistry.getAllTools().length,
+                activeBackgroundJobs: activeJobs,
+                loadedPlugins: pluginsCount,
+                osName: os.type() + ' ' + os.release(),
+                ramUsage: Math.round((os.totalmem() - os.freemem()) / os.totalmem() * 100)
+            }
+        });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+exports.getBackgroundJobs = async (req, res) => {
+    try {
+        const jobs = await BackgroundJob.find().sort({ nextRunAt: 1 }).limit(20);
+        res.json({ success: true, jobs });
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};
+
+exports.emergencyStop = async (req, res) => {
+    try {
+        // Stop all active background jobs
+        await BackgroundJob.updateMany({ isActive: true }, { $set: { isActive: false } });
+
+        // In a real system you might also want to set a global flag in plannerService to reject new processing
+        res.json({ success: true, message: "🚨 EMERGENCY STOP ENGAGED. All background jobs halted." });
+        console.warn("🛑 EMERGENCY KILL SWITCH ACTIVATED BY USER 🛑");
+    } catch (error) {
+        res.status(500).json({ success: false, message: error.message });
+    }
+};