upfynai-code 2.6.0 → 2.6.1

package/server/routes/user.js

@@ -1,106 +0,0 @@
-import express from 'express';
-import { userDb } from '../database/db.js';
-import { authenticateToken } from '../middleware/auth.js';
-import { getSystemGitConfig } from '../utils/gitConfig.js';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-const router = express.Router();
-
-router.get('/git-config', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    let gitConfig = await userDb.getGitConfig(userId);
-
-    // If database is empty, try to get from system git config
-    if (!gitConfig || (!gitConfig.git_name && !gitConfig.git_email)) {
-      const systemConfig = await getSystemGitConfig();
-
-      // If system has values, save them to database for this user
-      if (systemConfig.git_name || systemConfig.git_email) {
-        await userDb.updateGitConfig(userId, systemConfig.git_name, systemConfig.git_email);
-        gitConfig = systemConfig;
-        // auto-populated git config from system
-      }
-    }
-
-    res.json({
-      success: true,
-      gitName: gitConfig?.git_name || null,
-      gitEmail: gitConfig?.git_email || null
-    });
-  } catch (error) {
-    // git config error
-    res.status(500).json({ error: 'Failed to get git configuration' });
-  }
-});
-
-// Apply git config globally via git config --global
-router.post('/git-config', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    const { gitName, gitEmail } = req.body;
-
-    if (!gitName || !gitEmail) {
-      return res.status(400).json({ error: 'Git name and email are required' });
-    }
-
-    // Validate email format
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(gitEmail)) {
-      return res.status(400).json({ error: 'Invalid email format' });
-    }
-
-    await userDb.updateGitConfig(userId, gitName, gitEmail);
-
-    try {
-      await execAsync(`git config --global user.name "${gitName.replace(/"/g, '\\"')}"`);
-      await execAsync(`git config --global user.email "${gitEmail.replace(/"/g, '\\"')}"`);
-      // git config applied
-    } catch (gitError) {
-      // git config apply error
-    }
-
-    res.json({
-      success: true,
-      gitName,
-      gitEmail
-    });
-  } catch (error) {
-    // git config update error
-    res.status(500).json({ error: 'Failed to update git configuration' });
-  }
-});
-
-router.post('/complete-onboarding', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    await userDb.completeOnboarding(userId);
-
-    res.json({
-      success: true,
-      message: 'Onboarding completed successfully'
-    });
-  } catch (error) {
-    // onboarding error
-    res.status(500).json({ error: 'Failed to complete onboarding' });
-  }
-});
-
-router.get('/onboarding-status', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    const hasCompleted = await userDb.hasCompletedOnboarding(userId);
-
-    res.json({
-      success: true,
-      hasCompletedOnboarding: hasCompleted
-    });
-  } catch (error) {
-    // onboarding status error
-    res.status(500).json({ error: 'Failed to check onboarding status' });
-  }
-});
-
-export default router;

package/server/routes/vapi-chat.js

@@ -1,94 +0,0 @@
-import express from 'express';
-
-const router = express.Router();
-
-const VAPI_PRIVATE_KEY = process.env.VAPI_PRIVATE_KEY;
-const VAPI_PUBLIC_KEY = process.env.VAPI_PUBLIC_KEY;
-const VAPI_ASSISTANT_ID = process.env.VAPI_ASSISTANT_ID;
-
-/**
- * POST /api/vapi/chat — Proxy to VAPI Chat API
- * Body: { message, chatId? }
- * Returns: { reply, chatId }
- */
-router.post('/chat', async (req, res) => {
-  if (!VAPI_PRIVATE_KEY || !VAPI_ASSISTANT_ID) {
-    return res.status(503).json({ error: 'VAPI chat not configured' });
-  }
-
-  const { message, chatId } = req.body;
-  if (!message || typeof message !== 'string') {
-    return res.status(400).json({ error: 'Message is required' });
-  }
-
-  try {
-    const body = {
-      assistantId: VAPI_ASSISTANT_ID,
-      input: message.slice(0, 2000),
-    };
-    if (chatId) body.previousChatId = chatId;
-
-    const response = await fetch('https://api.vapi.ai/chat', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${VAPI_PRIVATE_KEY}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const err = await response.text().catch(() => '');
-      return res.status(response.status).json({ error: 'VAPI chat request failed' });
-    }
-
-    const data = await response.json();
-
-    // Extract the assistant's reply from the output array
-    const assistantMsg = data.output?.find(o => o.role === 'assistant');
-    const reply = assistantMsg?.content || data.output?.[0]?.content || 'No response';
-
-    res.json({
-      reply,
-      chatId: data.chat?.id || chatId || null,
-    });
-  } catch (error) {
-    res.status(500).json({ error: 'Chat request failed' });
-  }
-});
-
-/**
- * POST /api/vapi/call — Create a VAPI web call server-side
- * Returns: { webCallUrl, callId }
- */
-router.post('/call', async (req, res) => {
-  if (!VAPI_PUBLIC_KEY || !VAPI_ASSISTANT_ID) {
-    return res.status(503).json({ error: 'VAPI voice not configured' });
-  }
-
-  try {
-    const response = await fetch('https://api.vapi.ai/call/web', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${VAPI_PUBLIC_KEY}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ assistantId: VAPI_ASSISTANT_ID }),
-    });
-
-    if (!response.ok) {
-      const err = await response.text().catch(() => '');
-      return res.status(response.status).json({ error: 'Failed to create call', details: err });
-    }
-
-    const data = await response.json();
-    res.json({
-      webCallUrl: data.webCallUrl || data.transport?.callUrl,
-      callId: data.id,
-    });
-  } catch (error) {
-    res.status(500).json({ error: 'Call creation failed' });
-  }
-});
-
-export default router;

package/server/routes/voice.js

@@ -1,194 +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;
-  }
-}
-
-/**
- * POST /api/voice/stt — Speech-to-text
- * Primary: OpenAI Whisper API (cloud)
- * Fallback: nodejs-whisper (local, when no API key)
- */
-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 apiKey = await getOpenAIKey(req.user?.id);
-
-    // Try OpenAI Whisper API first
-    if (apiKey) {
-      try {
-        const FormData = (await import('form-data')).default;
-        const formData = new FormData();
-        formData.append('file', req.file.buffer, {
-          filename: req.file.originalname || 'audio.webm',
-          contentType: req.file.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 errorData = await response.json().catch(() => ({}));
-          throw new Error(errorData.error?.message || `Whisper API error: ${response.status}`);
-        }
-
-        const data = await response.json();
-        let text = data.text || '';
-
-        // Enhancement modes (prompt, vibe, architect)
-        if (text && mode !== 'default') {
-          text = await enhanceTranscription(text, mode, apiKey);
-        }
-
-        return res.json({ text, source: 'openai' });
-      } catch (err) {
-        // If cloud fails, try local fallback
-      }
-    }
-
-    // Fallback: local nodejs-whisper
-    const localAvailable = await isWhisperAvailable();
-    if (localAvailable) {
-      // Write buffer to temp file for nodejs-whisper
-      const tmpFile = path.join(os.tmpdir(), `stt-${Date.now()}.webm`);
-      await fs.writeFile(tmpFile, req.file.buffer);
-      try {
-        const text = await transcribeLocal(tmpFile);
-        if (text) return res.json({ text, source: 'local' });
-      } finally {
-        await fs.unlink(tmpFile).catch(() => {});
-      }
-    }
-
-    return res.status(500).json({ error: 'No STT engine available. Add your OpenAI key in Settings > AI Providers, or install nodejs-whisper + ffmpeg for local transcription.' });
-  } 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;

package/server/routes/workflows.js

@@ -1,118 +0,0 @@
-import express from 'express';
-import { workflowDb, webhookDb } from '../database/db.js';
-import { refreshWorkflowSchedule, stopWorkflowSchedule, executeWorkflow } from '../services/workflowScheduler.js';
-
-const router = express.Router();
-
-// GET /api/workflows — list all workflows for the user
-router.get('/', async (req, res) => {
-  try {
-    const workflows = await workflowDb.getAll(req.user.id);
-    const parsed = workflows.map(w => ({
-      ...w,
-      steps: typeof w.steps === 'string' ? JSON.parse(w.steps) : w.steps
-    }));
-    res.json({ workflows: parsed });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to fetch workflows' });
-  }
-});
-
-// POST /api/workflows — create a workflow
-router.post('/', async (req, res) => {
-  try {
-    const { name, description, steps, schedule, schedule_enabled, schedule_timezone } = req.body;
-    if (!name || !name.trim()) return res.status(400).json({ error: 'Name is required' });
-    if (!Array.isArray(steps)) return res.status(400).json({ error: 'Steps must be an array' });
-
-    const workflow = await workflowDb.create(req.user.id, {
-      name: name.trim(),
-      description: description?.trim() || null,
-      steps,
-      schedule: schedule || null,
-      schedule_enabled: !!schedule_enabled,
-      schedule_timezone: schedule_timezone || 'UTC'
-    });
-
-    // Sync cron scheduler
-    if (workflow.id) refreshWorkflowSchedule(workflow.id, req.user.id);
-
-    res.json({ success: true, workflow });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to create workflow' });
-  }
-});
-
-// PUT /api/workflows/:id — update a workflow
-router.put('/:id', async (req, res) => {
-  try {
-    const { name, description, steps, schedule, schedule_enabled, schedule_timezone } = req.body;
-    if (!name || !name.trim()) return res.status(400).json({ error: 'Name is required' });
-
-    const wfId = Number(req.params.id);
-    const updated = await workflowDb.update(wfId, req.user.id, {
-      name: name.trim(),
-      description: description?.trim() || null,
-      steps: steps || [],
-      schedule: schedule || null,
-      schedule_enabled: !!schedule_enabled,
-      schedule_timezone: schedule_timezone || 'UTC'
-    });
-
-    if (!updated) return res.status(404).json({ error: 'Workflow not found' });
-
-    // Sync cron scheduler
-    refreshWorkflowSchedule(wfId, req.user.id);
-
-    res.json({ success: true });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to update workflow' });
-  }
-});
-
-// DELETE /api/workflows/:id — delete a workflow
-router.delete('/:id', async (req, res) => {
-  try {
-    const wfId = Number(req.params.id);
-    const deleted = await workflowDb.delete(wfId, req.user.id);
-    if (!deleted) return res.status(404).json({ error: 'Workflow not found' });
-
-    stopWorkflowSchedule(wfId);
-
-    res.json({ success: true });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to delete workflow' });
-  }
-});
-
-// POST /api/workflows/:id/run — execute a workflow (manual trigger)
-router.post('/:id/run', async (req, res) => {
-  try {
-    const workflow = await workflowDb.getById(Number(req.params.id), req.user.id);
-    if (!workflow) return res.status(404).json({ error: 'Workflow not found' });
-
-    const steps = typeof workflow.steps === 'string' ? JSON.parse(workflow.steps) : workflow.steps;
-    if (!steps.length) return res.status(400).json({ error: 'Workflow has no steps' });
-
-    const result = await executeWorkflow({ ...workflow, steps });
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to run workflow' });
-  }
-});
-
-// GET /api/workflows/:id/runs — list execution history for a workflow
-router.get('/:id/runs', async (req, res) => {
-  try {
-    const runs = await workflowDb.getRuns(Number(req.params.id), req.user.id);
-    const parsed = runs.map(r => ({
-      ...r,
-      result: typeof r.result === 'string' ? (() => { try { return JSON.parse(r.result); } catch { return r.result; } })() : r.result
-    }));
-    res.json({ runs: parsed });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to fetch workflow runs' });
-  }
-});
-
-export default router;