samarthya-bot 1.1.4 → 2.0.0

package/backend/services/llm/llmService.js

@@ -118,7 +118,13 @@ NEVER SAY YOU PERFORMED AN ACTION (like sending an email or saving a file) WITHO
         } else if (provider === 'mistral') {
             return this.chatOpenAICompatible(messages, systemPrompt, user, 'https://api.mistral.ai/v1/chat/completions', process.env.MISTRAL_API_KEY, customModel || 'mistral-large-latest');
         } else if (provider === 'anthropic') {
-            return this.chatGemini(messages, systemPrompt, user, customModel || 'gemini-2.5-flash'); // fallback to Gemini for Anthropic until SDK is added
+            return this.chatAnthropic(messages, systemPrompt, user, customModel || 'claude-sonnet-4-20250514');
+        } else if (provider === 'deepseek') {
+            return this.chatOpenAICompatible(messages, systemPrompt, user, 'https://api.deepseek.com/v1/chat/completions', process.env.DEEPSEEK_API_KEY, customModel || 'deepseek-chat');
+        } else if (provider === 'qwen') {
+            return this.chatOpenAICompatible(messages, systemPrompt, user, 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions', process.env.QWEN_API_KEY, customModel || 'qwen-plus');
+        } else if (provider === 'openrouter') {
+            return this.chatOpenRouter(messages, systemPrompt, user, customModel || 'google/gemini-2.5-flash');
         }
 
         return this.chatGemini(messages, systemPrompt, user, customModel || 'gemini-2.5-flash');
@@ -292,6 +298,117 @@ NEVER SAY YOU PERFORMED AN ACTION (like sending an email or saving a file) WITHO
         }
     }
 
+    /**
+     * Anthropic Claude API (Native Messages API)
+     * Claude uses a different API format than OpenAI
+     */
+    async chatAnthropic(messages, systemPrompt, user = null, modelName = 'claude-sonnet-4-20250514') {
+        try {
+            const apiKey = process.env.ANTHROPIC_API_KEY;
+            if (!apiKey || apiKey === 'dummy') {
+                return this.getFallbackResponse(messages[messages.length - 1]?.content, user);
+            }
+
+            // Claude uses a different message format
+            const claudeMessages = messages
+                .filter(m => m.role !== 'system')
+                .map(m => ({
+                    role: m.role === 'assistant' ? 'assistant' : 'user',
+                    content: m.content
+                }));
+
+            // Ensure first message is from user
+            if (claudeMessages.length === 0 || claudeMessages[0].role !== 'user') {
+                claudeMessages.unshift({ role: 'user', content: 'Hello' });
+            }
+
+            const response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01'
+                },
+                body: JSON.stringify({
+                    model: modelName,
+                    max_tokens: 8192,
+                    system: systemPrompt,
+                    messages: claudeMessages,
+                    temperature: 0.7
+                })
+            });
+
+            if (!response.ok) {
+                const errText = await response.text();
+                console.error('Anthropic API Error:', errText);
+                return this.getFallbackResponse(messages[messages.length - 1]?.content, user);
+            }
+
+            const data = await response.json();
+            const textContent = data.content?.find(c => c.type === 'text');
+            return {
+                content: textContent?.text || 'Empty response from Claude',
+                tokensUsed: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+                model: modelName
+            };
+        } catch (error) {
+            console.error('Anthropic Error:', error.message);
+            return this.getFallbackResponse(messages[messages.length - 1]?.content, user);
+        }
+    }
+
+    /**
+     * OpenRouter API — access 100+ models through a single API key
+     * Uses OpenAI-compatible format with extra headers
+     */
+    async chatOpenRouter(messages, systemPrompt, user = null, modelName = 'google/gemini-2.5-flash') {
+        try {
+            const apiKey = process.env.OPENROUTER_API_KEY;
+            if (!apiKey || apiKey === 'dummy') {
+                return this.getFallbackResponse(messages[messages.length - 1]?.content, user);
+            }
+
+            const apiMessages = [
+                { role: 'system', content: systemPrompt },
+                ...messages.map(m => ({
+                    role: m.role === 'assistant' ? 'assistant' : 'user',
+                    content: m.content
+                }))
+            ];
+
+            const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`,
+                    'HTTP-Referer': 'https://github.com/mebishnusahu0595/SamarthyaBot',
+                    'X-Title': 'SamarthyaBot'
+                },
+                body: JSON.stringify({
+                    model: modelName,
+                    messages: apiMessages,
+                    temperature: 0.7
+                })
+            });
+
+            if (!response.ok) {
+                const errText = await response.text();
+                console.error('OpenRouter API Error:', errText);
+                return this.getFallbackResponse(messages[messages.length - 1]?.content, user);
+            }
+
+            const data = await response.json();
+            return {
+                content: data.choices?.[0]?.message?.content || 'Empty response from OpenRouter',
+                tokensUsed: data.usage?.total_tokens || 0,
+                model: `openrouter:${modelName}`
+            };
+        } catch (error) {
+            console.error('OpenRouter Error:', error.message);
+            return this.getFallbackResponse(messages[messages.length - 1]?.content, user);
+        }
+    }
+
     /**
      * Screen Understanding via Gemini Vision 
      * Takes a base64 screenshot and analyzes it

package/backend/services/security/sandboxService.js

@@ -0,0 +1,115 @@
+/**
+ * Workspace Security Sandbox for SamarthyaBot
+ * Restricts file and command operations to the configured workspace
+ * Inspired by PicoClaw's restrict_to_workspace feature
+ */
+
+const path = require('path');
+const os = require('os');
+
+class SandboxService {
+    constructor() {
+        this.enabled = process.env.RESTRICT_TO_WORKSPACE !== 'false'; // default: true
+        this.workspace = process.env.WORKSPACE_PATH || path.join(os.homedir(), 'SamarthyaBot_Files');
+
+        // Dangerous command patterns (always blocked, even if sandbox is off)
+        this.blockedPatterns = [
+            /rm\s+(-rf|-fr|--no-preserve-root)\s/i,
+            /del\s+\/f/i,
+            /rmdir\s+\/s/i,
+            /format\s+/i,
+            /mkfs\s/i,
+            /diskpart/i,
+            /dd\s+if=/i,
+            /\/dev\/sd[a-z]/i,
+            /shutdown/i,
+            /reboot/i,
+            /poweroff/i,
+            /init\s+[06]/i,
+            /:()\{\s*:\|:&\s*\};:/,  // Fork bomb
+            />\s*\/dev\/sda/i,
+            /mv\s+\/\s/i,           // mv / (moving root)
+            /chmod\s+-R\s+777\s+\//i, // chmod 777 on root
+        ];
+    }
+
+    /**
+     * Validate that a file path is within the allowed workspace
+     * @param {string} filePath - The file path to validate
+     * @returns {{ allowed: boolean, reason: string }}
+     */
+    validatePath(filePath) {
+        if (!this.enabled) return { allowed: true, reason: 'Sandbox disabled' };
+
+        const resolvedPath = path.resolve(filePath);
+        const resolvedWorkspace = path.resolve(this.workspace);
+
+        if (resolvedPath.startsWith(resolvedWorkspace)) {
+            return { allowed: true, reason: 'Path is within workspace' };
+        }
+
+        // Allow /tmp for scratch files
+        if (resolvedPath.startsWith('/tmp') || resolvedPath.startsWith(os.tmpdir())) {
+            return { allowed: true, reason: 'Path is in temp directory' };
+        }
+
+        return {
+            allowed: false,
+            reason: `🔒 Security: Path "${filePath}" is outside the workspace. Only files within "${this.workspace}" can be accessed. Set RESTRICT_TO_WORKSPACE=false in .env to disable this restriction.`
+        };
+    }
+
+    /**
+     * Validate that a command is safe to execute
+     * @param {string} command - The shell command to validate
+     * @returns {{ allowed: boolean, reason: string }}
+     */
+    validateCommand(command) {
+        // Always check blocked patterns (even if sandbox is disabled)
+        for (const pattern of this.blockedPatterns) {
+            if (pattern.test(command)) {
+                return {
+                    allowed: false,
+                    reason: `🛡️ Safety Guard: Command blocked — dangerous pattern detected ("${command.substring(0, 50)}..."). This command could harm your system.`
+                };
+            }
+        }
+
+        // If sandbox is enabled, check that command paths are within workspace
+        if (this.enabled) {
+            // Extract paths from command (basic heuristic)
+            const pathRegex = /(?:^|\s)(\/[^\s;|&]+)/g;
+            let match;
+            while ((match = pathRegex.exec(command)) !== null) {
+                const cmdPath = match[1];
+                // Skip common system binaries
+                if (cmdPath.startsWith('/usr/') || cmdPath.startsWith('/bin/') ||
+                    cmdPath.startsWith('/sbin/') || cmdPath.startsWith('/tmp/')) {
+                    continue;
+                }
+                const validation = this.validatePath(cmdPath);
+                if (!validation.allowed) {
+                    return {
+                        allowed: false,
+                        reason: `🔒 Security: Command references path outside workspace — ${validation.reason}`
+                    };
+                }
+            }
+        }
+
+        return { allowed: true, reason: 'Command is safe' };
+    }
+
+    /**
+     * Get workspace info for status display
+     */
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            workspace: this.workspace,
+            blockedPatterns: this.blockedPatterns.length
+        };
+    }
+}
+
+module.exports = new SandboxService();

package/backend/services/voice/voiceService.js

@@ -0,0 +1,151 @@
+/**
+ * Voice Transcription Service for SamarthyaBot
+ * Uses Groq Whisper API to convert voice notes to text
+ * Supports OGG (Telegram), MP3, WAV, M4A formats
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class VoiceService {
+    constructor() {
+        this.groqApiKey = process.env.GROQ_API_KEY;
+        this.model = 'whisper-large-v3-turbo'; // Groq's fast Whisper model
+    }
+
+    /**
+     * Transcribe an audio file using Groq Whisper API
+     * @param {string|Buffer} audioInput - File path or Buffer of audio data
+     * @param {string} fileName - Original filename (for MIME type detection)
+     * @param {string} language - Language hint (e.g., 'hi' for Hindi, 'en' for English)
+     * @returns {Promise<{text: string, language: string, duration: number}>}
+     */
+    async transcribe(audioInput, fileName = 'audio.ogg', language = null) {
+        if (!this.groqApiKey || this.groqApiKey === 'your_groq_api_key') {
+            return {
+                text: null,
+                error: 'Voice transcription not available — GROQ_API_KEY not configured. Get a free key at https://console.groq.com'
+            };
+        }
+
+        try {
+            let audioBuffer;
+            if (typeof audioInput === 'string') {
+                // It's a file path
+                audioBuffer = fs.readFileSync(audioInput);
+            } else {
+                audioBuffer = audioInput;
+            }
+
+            // Build multipart form data manually (no external dependency)
+            const boundary = '----SamarthyaBotVoice' + Date.now();
+            const mimeType = this.getMimeType(fileName);
+
+            const bodyParts = [];
+
+            // File part
+            bodyParts.push(
+                `--${boundary}\r\n`,
+                `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n`,
+                `Content-Type: ${mimeType}\r\n\r\n`
+            );
+
+            const headerBuffer = Buffer.from(bodyParts.join(''));
+            const footerParts = [`\r\n--${boundary}\r\n`,
+                `Content-Disposition: form-data; name="model"\r\n\r\n`,
+            `${this.model}\r\n`
+            ];
+
+            if (language) {
+                footerParts.push(
+                    `--${boundary}\r\n`,
+                    `Content-Disposition: form-data; name="language"\r\n\r\n`,
+                    `${language}\r\n`
+                );
+            }
+
+            footerParts.push(
+                `--${boundary}\r\n`,
+                `Content-Disposition: form-data; name="response_format"\r\n\r\n`,
+                `verbose_json\r\n`,
+                `--${boundary}--\r\n`
+            );
+
+            const footerBuffer = Buffer.from(footerParts.join(''));
+            const body = Buffer.concat([headerBuffer, audioBuffer, footerBuffer]);
+
+            const response = await fetch('https://api.groq.com/openai/v1/audio/transcriptions', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.groqApiKey}`,
+                    'Content-Type': `multipart/form-data; boundary=${boundary}`
+                },
+                body: body
+            });
+
+            if (!response.ok) {
+                const errText = await response.text();
+                console.error('❌ Voice transcription error:', errText);
+                return { text: null, error: `Transcription failed: ${response.status}` };
+            }
+
+            const data = await response.json();
+            console.log(`🎙️ Voice transcribed: "${(data.text || '').substring(0, 60)}..." (${data.language || 'auto'}, ${Math.round(data.duration || 0)}s)`);
+
+            return {
+                text: data.text || '',
+                language: data.language || 'unknown',
+                duration: data.duration || 0
+            };
+        } catch (error) {
+            console.error('❌ Voice service error:', error.message);
+            return { text: null, error: error.message };
+        }
+    }
+
+    /**
+     * Download a file from URL and transcribe it (for Telegram voice notes)
+     * @param {string} fileUrl - URL of the audio file
+     * @param {string} language - Language hint
+     */
+    async transcribeFromUrl(fileUrl, language = null) {
+        try {
+            const response = await fetch(fileUrl);
+            if (!response.ok) {
+                return { text: null, error: `Failed to download audio: ${response.status}` };
+            }
+
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+
+            // Extract filename from URL
+            const urlParts = fileUrl.split('/');
+            const fileName = urlParts[urlParts.length - 1] || 'audio.oga';
+
+            return this.transcribe(buffer, fileName, language);
+        } catch (error) {
+            console.error('❌ Voice download error:', error.message);
+            return { text: null, error: error.message };
+        }
+    }
+
+    getMimeType(fileName) {
+        const ext = path.extname(fileName).toLowerCase();
+        const mimeMap = {
+            '.ogg': 'audio/ogg',
+            '.oga': 'audio/ogg',
+            '.mp3': 'audio/mpeg',
+            '.wav': 'audio/wav',
+            '.m4a': 'audio/m4a',
+            '.webm': 'audio/webm',
+            '.flac': 'audio/flac'
+        };
+        return mimeMap[ext] || 'audio/ogg';
+    }
+
+    isAvailable() {
+        return !!(this.groqApiKey && this.groqApiKey !== 'your_groq_api_key');
+    }
+}
+
+module.exports = new VoiceService();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "samarthya-bot",
-    "version": "1.1.4",
+    "version": "2.0.0",
     "description": "Privacy-First Local Agentic OS & Command Center",
     "main": "backend/server.js",
     "bin": {
@@ -47,4 +47,4 @@
         "type": "git",
         "url": "https://github.com/mebishnusahu0595/SamarthyaBot.git"
     }
-}
+}

package/server.log

@@ -0,0 +1,35 @@
+
+> samarthya-agent@1.0.0 start
+> node server.js
+
+[dotenv@17.3.1] injecting env (0) from .env -- tip: 🤖 agentic secret storage: https://dotenvx.com/as2
+✅ MongoDB Connected: localhost
+
+╔══════════════════════════════════════════════════════╗
+║                                                      ║
+║   🧠 SamarthyaBot Server v1.1.0                      ║
+║   Privacy-first Personal AI Operator                 ║
+║                                                      ║
+║   🌐 Server:    http://localhost:5000             ║
+║   📡 Socket:    ws://localhost:5000               ║
+║   🔗 Health:    http://localhost:5000/api/health  ║
+║   📱 WhatsApp:  /api/whatsapp/webhook                ║
+║   🤖 Telegram:  /api/telegram/webhook                ║
+║   👁️  Vision:    /api/screen/analyze                 ║
+║                                                      ║
+║   🇮🇳 Built for Indian Workflows                      ║
+║   📦 Ollama: ❌ Disabled                         ║
+║   🔄 Autonomous Background Engine: ✅ Active         ║
+║   🔌 Dynamic Plugin Engine: ✅ Active                ║
+║   🧠 Active AI: GEMINI (gemini-2.5-flash)                                                  ║
+║                                                      ║
+╚══════════════════════════════════════════════════════╝
+        
+🔄 Background Autonomous Mode Started (Checking every 1 minute)
+GET /api/health 200 13.413 ms - 121
+GET / 200 5.827 ms - 947
+GET /assets/index-J7XSVHCz.css 200 3.896 ms - 7514
+GET /assets/index-BFRAq8Y1.js 200 5.924 ms - 409640
+GET /logo.png 200 1.936 ms - 395392
+GET /api/auth/profile 200 31.161 ms - 457
+GET /favicon.svg 200 1.891 ms - 847