upfynai-code 2.9.0 → 2.9.2

package/server/routes/voice.js

@@ -0,0 +1,235 @@
+import express from 'express';
+import multer from 'multer';
+import path from 'path';
+import os from 'os';
+import { promises as fs } from 'fs';
+import { isWhisperAvailable, transcribeLocal } from '../services/whisperService.js';
+
+const router = express.Router();
+const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 25 * 1024 * 1024 } }); // 25MB max
+
+/**
+ * Helper: Get user's OpenAI key (BYOK) or server env key.
+ * Imported lazily to avoid circular deps.
+ */
+async function getOpenAIKey(userId) {
+  try {
+    const { credentialsDb } = await import('../database/db.js');
+    const creds = await credentialsDb.getCredentials(userId, 'openai_key');
+    const active = creds.find(c => c.is_active);
+    return active?.credential_value || process.env.OPENAI_API_KEY || null;
+  } catch {
+    return process.env.OPENAI_API_KEY || null;
+  }
+}
+
+/**
+ * Transcribe audio via self-hosted Whisper (WHISPER_URL) or OpenAI API.
+ * Returns { text, source } or null if all methods fail.
+ */
+async function transcribeAudio(fileBuffer, originalname, mimetype, userId) {
+  const FormData = (await import('form-data')).default;
+
+  // Strategy 1: Self-hosted Whisper
+  const whisperUrl = process.env.WHISPER_URL;
+  if (whisperUrl) {
+    try {
+      const formData = new FormData();
+      formData.append('file', fileBuffer, {
+        filename: originalname || 'audio.webm',
+        contentType: mimetype || 'audio/webm'
+      });
+      formData.append('model', 'whisper-1');
+      formData.append('response_format', 'json');
+      formData.append('language', 'en');
+
+      const endpoint = whisperUrl.replace(/\/+$/, '') + '/v1/audio/transcriptions';
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: formData.getHeaders(),
+        body: formData
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.text) return { text: data.text, source: 'self-hosted' };
+      }
+    } catch {
+      // Self-hosted failed, try next
+    }
+  }
+
+  // Strategy 2: OpenAI Whisper API (BYOK or server key)
+  const apiKey = await getOpenAIKey(userId);
+  if (apiKey) {
+    try {
+      const formData = new FormData();
+      formData.append('file', fileBuffer, {
+        filename: originalname || 'audio.webm',
+        contentType: mimetype || 'audio/webm'
+      });
+      formData.append('model', 'whisper-1');
+      formData.append('response_format', 'json');
+      formData.append('language', 'en');
+
+      const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          ...formData.getHeaders()
+        },
+        body: formData
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.text) return { text: data.text, source: 'openai' };
+      }
+    } catch {
+      // OpenAI failed, try next
+    }
+  }
+
+  // Strategy 3: Local nodejs-whisper fallback
+  const localAvailable = await isWhisperAvailable();
+  if (localAvailable) {
+    const tmpFile = path.join(os.tmpdir(), `stt-${Date.now()}.webm`);
+    await fs.writeFile(tmpFile, fileBuffer);
+    try {
+      const text = await transcribeLocal(tmpFile);
+      if (text) return { text, source: 'local' };
+    } finally {
+      await fs.unlink(tmpFile).catch(() => {});
+    }
+  }
+
+  return null;
+}
+
+/**
+ * POST /api/voice/stt — Speech-to-text
+ * Priority: 1) Self-hosted Whisper (WHISPER_URL), 2) OpenAI API, 3) Local nodejs-whisper
+ */
+router.post('/stt', upload.single('audio'), async (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ error: 'No audio file provided' });
+    }
+
+    const mode = req.body?.mode || 'default';
+    const result = await transcribeAudio(req.file.buffer, req.file.originalname, req.file.mimetype, req.user?.id);
+
+    if (!result) {
+      return res.status(500).json({ error: 'Speech recognition is temporarily unavailable. Please try again.' });
+    }
+
+    let text = result.text;
+
+    // Enhancement modes (prompt, vibe, architect)
+    if (text && mode !== 'default') {
+      const apiKey = await getOpenAIKey(req.user?.id);
+      if (apiKey) {
+        text = await enhanceTranscription(text, mode, apiKey);
+      }
+    }
+
+    return res.json({ text, source: result.source });
+  } catch (error) {
+    res.status(500).json({ error: 'Transcription failed' });
+  }
+});
+
+/**
+ * POST /api/voice/tts — Text-to-speech using Edge-TTS
+ * Returns audio/mp3 blob
+ */
+router.post('/tts', async (req, res) => {
+  try {
+    const { text, voice = 'en-US-AriaNeural' } = req.body;
+    if (!text || typeof text !== 'string') {
+      return res.status(400).json({ error: 'Text is required' });
+    }
+
+    // Truncate very long text to avoid excessive audio generation
+    const truncated = text.length > 5000 ? text.slice(0, 5000) : text;
+
+    const { EdgeTTS } = await import('edge-tts-universal');
+    const tts = new EdgeTTS(truncated, voice);
+    const result = await tts.synthesize();
+    const audioBuffer = Buffer.from(await result.audio.arrayBuffer());
+
+    res.setHeader('Content-Type', 'audio/mp3');
+    res.setHeader('Content-Length', audioBuffer.length);
+    res.send(audioBuffer);
+  } catch (error) {
+    res.status(500).json({ error: 'TTS synthesis failed' });
+  }
+});
+
+/**
+ * GET /api/voice/voices — List available TTS voices
+ */
+router.get('/voices', async (req, res) => {
+  try {
+    const { listVoices } = await import('edge-tts-universal');
+    const voices = await listVoices();
+
+    // Filter to English voices and simplify the response
+    const englishVoices = voices
+      .filter(v => v.Locale?.startsWith('en-'))
+      .map(v => ({
+        id: v.ShortName,
+        name: v.FriendlyName || v.ShortName,
+        locale: v.Locale,
+        gender: v.Gender
+      }));
+
+    res.json({ voices: englishVoices });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch voices' });
+  }
+});
+
+/**
+ * Enhance transcribed text using GPT (prompt engineering, vibe coding, etc.)
+ */
+async function enhanceTranscription(text, mode, apiKey) {
+  try {
+    const OpenAI = (await import('openai')).default;
+    const openai = new OpenAI({ apiKey });
+
+    let systemMessage, prompt, temperature = 0.7, maxTokens = 800;
+
+    switch (mode) {
+      case 'prompt':
+        systemMessage = 'You are an expert prompt engineer who creates clear, detailed, and effective prompts.';
+        prompt = `Transform the following rough instruction into a clear, detailed, and context-aware AI prompt.\n\nYour enhanced prompt should:\n1. Be specific and unambiguous\n2. Include relevant context and constraints\n3. Specify the desired output format\n4. Use clear, actionable language\n\nRough instruction: "${text}"\n\nEnhanced prompt:`;
+        break;
+      case 'vibe':
+      case 'instructions':
+      case 'architect':
+        systemMessage = 'You are a helpful assistant that formats ideas into clear, actionable instructions for AI agents.';
+        temperature = 0.5;
+        prompt = `Transform the following idea into clear, well-structured instructions that an AI agent can easily understand and execute.\n\nIMPORTANT RULES:\n- Format as clear, step-by-step instructions\n- Add reasonable implementation details based on common patterns\n- Only include details directly related to what was asked\n- Do NOT add features or functionality not mentioned\n- Keep the original intent and scope intact\n\nIdea: "${text}"\n\nAgent instructions:`;
+        break;
+      default:
+        return text;
+    }
+
+    const completion = await openai.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages: [
+        { role: 'system', content: systemMessage },
+        { role: 'user', content: prompt }
+      ],
+      temperature,
+      max_tokens: maxTokens
+    });
+
+    return completion.choices[0]?.message?.content || text;
+  } catch {
+    return text; // Fallback to original on error
+  }
+}
+
+export default router;

package/server/routes/webhooks.js

@@ -0,0 +1,166 @@
+import express from 'express';
+import { webhookDb } from '../database/db.js';
+
+const router = express.Router();
+
+// GET /api/webhooks — list all webhooks for the user
+router.get('/', async (req, res) => {
+  try {
+    const webhooks = await webhookDb.getAll(req.user.id);
+    res.json({ webhooks });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch webhooks' });
+  }
+});
+
+// POST /api/webhooks — create a webhook
+router.post('/', async (req, res) => {
+  try {
+    const { name, url, method, headers, description } = req.body;
+    if (!name || !name.trim()) return res.status(400).json({ error: 'Name is required' });
+    if (!url || !url.trim()) return res.status(400).json({ error: 'URL is required' });
+
+    try { new URL(url); } catch { return res.status(400).json({ error: 'Invalid URL' }); }
+
+    const allowedMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+    const m = (method || 'POST').toUpperCase();
+    if (!allowedMethods.includes(m)) return res.status(400).json({ error: 'Invalid HTTP method' });
+
+    // Validate headers is valid JSON if provided
+    let headersStr = '{}';
+    if (headers) {
+      if (typeof headers === 'string') {
+        try { JSON.parse(headers); headersStr = headers; } catch { return res.status(400).json({ error: 'Headers must be valid JSON' }); }
+      } else {
+        headersStr = JSON.stringify(headers);
+      }
+    }
+
+    const webhook = await webhookDb.create(req.user.id, {
+      name: name.trim(),
+      url: url.trim(),
+      method: m,
+      headers: headersStr,
+      description: description?.trim() || null
+    });
+    res.json({ success: true, webhook });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to create webhook' });
+  }
+});
+
+// PUT /api/webhooks/:id — update a webhook
+router.put('/:id', async (req, res) => {
+  try {
+    const { name, url, method, headers, description } = req.body;
+    if (!name || !name.trim()) return res.status(400).json({ error: 'Name is required' });
+    if (!url || !url.trim()) return res.status(400).json({ error: 'URL is required' });
+
+    try { new URL(url); } catch { return res.status(400).json({ error: 'Invalid URL' }); }
+
+    let headersStr = '{}';
+    if (headers) {
+      if (typeof headers === 'string') {
+        try { JSON.parse(headers); headersStr = headers; } catch { return res.status(400).json({ error: 'Headers must be valid JSON' }); }
+      } else {
+        headersStr = JSON.stringify(headers);
+      }
+    }
+
+    const updated = await webhookDb.update(Number(req.params.id), req.user.id, {
+      name: name.trim(),
+      url: url.trim(),
+      method: (method || 'POST').toUpperCase(),
+      headers: headersStr,
+      description: description?.trim() || null
+    });
+
+    if (!updated) return res.status(404).json({ error: 'Webhook not found' });
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to update webhook' });
+  }
+});
+
+// DELETE /api/webhooks/:id — delete a webhook
+router.delete('/:id', async (req, res) => {
+  try {
+    const deleted = await webhookDb.delete(Number(req.params.id), req.user.id);
+    if (!deleted) return res.status(404).json({ error: 'Webhook not found' });
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to delete webhook' });
+  }
+});
+
+// POST /api/webhooks/:id/test — fire a test request to the webhook
+router.post('/:id/test', async (req, res) => {
+  try {
+    const webhook = await webhookDb.getById(Number(req.params.id), req.user.id);
+    if (!webhook) return res.status(404).json({ error: 'Webhook not found' });
+
+    let parsedHeaders = {};
+    try { parsedHeaders = JSON.parse(webhook.headers || '{}'); } catch { /* ignore */ }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10000);
+
+    try {
+      const fetchOptions = {
+        method: webhook.method,
+        headers: {
+          'Content-Type': 'application/json',
+          'User-Agent': 'UpfynAI-Webhook/1.0',
+          ...parsedHeaders
+        },
+        signal: controller.signal
+      };
+
+      // Add test body for methods that support it
+      if (['POST', 'PUT', 'PATCH'].includes(webhook.method)) {
+        fetchOptions.body = JSON.stringify({
+          event: 'test',
+          webhook_id: webhook.id,
+          webhook_name: webhook.name,
+          timestamp: new Date().toISOString()
+        });
+      }
+
+      const response = await fetch(webhook.url, fetchOptions);
+      clearTimeout(timeout);
+
+      let body;
+      const contentType = response.headers.get('content-type') || '';
+      if (contentType.includes('application/json')) {
+        body = await response.json();
+      } else {
+        body = await response.text();
+        if (body.length > 2000) body = body.slice(0, 2000) + '...';
+      }
+
+      await webhookDb.updateLastTriggered(webhook.id);
+
+      res.json({
+        success: true,
+        result: {
+          status: response.status,
+          statusText: response.statusText,
+          body,
+          headers: Object.fromEntries(response.headers.entries())
+        }
+      });
+    } catch (fetchError) {
+      clearTimeout(timeout);
+      res.json({
+        success: false,
+        result: {
+          error: fetchError.name === 'AbortError' ? 'Request timed out (10s)' : fetchError.message
+        }
+      });
+    }
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to test webhook' });
+  }
+});
+
+export default router;