upfynai-code 3.0.4 → 3.2.0

package/server/routes/voice.js

@@ -1,235 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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;