upfynai-code 2.5.1 → 2.6.0

package/server/routes/vapi-chat.js

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

@@ -75,7 +75,6 @@ router.post('/stt', upload.single('audio'), async (req, res) => {
         return res.json({ text, source: 'openai' });
       } catch (err) {
         // If cloud fails, try local fallback
-        console.warn('[Voice STT] OpenAI API failed, trying local:', err.message);
       }
     }
 
@@ -95,7 +94,6 @@ router.post('/stt', upload.single('audio'), async (req, res) => {
 
     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) {
-    console.error('[Voice STT] Error:', error.message);
     res.status(500).json({ error: 'Transcription failed' });
   }
 });
@@ -123,7 +121,6 @@ router.post('/tts', async (req, res) => {
     res.setHeader('Content-Length', audioBuffer.length);
     res.send(audioBuffer);
   } catch (error) {
-    console.error('[Voice TTS] Error:', error.message);
     res.status(500).json({ error: 'TTS synthesis failed' });
   }
 });
@@ -148,7 +145,6 @@ router.get('/voices', async (req, res) => {
 
     res.json({ voices: englishVoices });
   } catch (error) {
-    console.error('[Voice Voices] Error:', error.message);
     res.status(500).json({ error: 'Failed to fetch voices' });
   }
 });

package/server/sandbox.js

@@ -0,0 +1,120 @@
+/**
+ * Sandbox Client — connects the backend to the separate sandbox-service on Railway.
+ * All sandbox operations are proxied to the sandbox service via HTTP.
+ */
+
+const SANDBOX_SERVICE_URL = process.env.SANDBOX_SERVICE_URL || 'http://localhost:4300';
+const SANDBOX_SERVICE_SECRET = process.env.SANDBOX_SERVICE_SECRET || 'dev-sandbox-secret';
+
+async function sandboxFetch(path, userId, body = null) {
+  const opts = {
+    method: body ? 'POST' : 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-sandbox-secret': SANDBOX_SERVICE_SECRET,
+      'x-user-id': String(userId),
+    },
+  };
+  if (body) opts.body = JSON.stringify(body);
+
+  const res = await fetch(`${SANDBOX_SERVICE_URL}${path}`, opts);
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || `Sandbox service error: ${res.status}`);
+  return data;
+}
+
+const sandboxClient = {
+
+  /**
+   * Check if the sandbox service is reachable.
+   */
+  async isAvailable() {
+    try {
+      const res = await fetch(`${SANDBOX_SERVICE_URL}/health`, { signal: AbortSignal.timeout(3000) });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Initialize a user's sandbox (creates if doesn't exist).
+   */
+  async initSandbox(userId) {
+    return sandboxFetch('/api/sandbox/init', userId, {});
+  },
+
+  /**
+   * Get sandbox status.
+   */
+  async getStatus(userId) {
+    return sandboxFetch('/api/sandbox/status', userId);
+  },
+
+  /**
+   * Destroy a user's sandbox.
+   */
+  async destroySandbox(userId) {
+    const res = await fetch(`${SANDBOX_SERVICE_URL}/api/sandbox`, {
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-sandbox-secret': SANDBOX_SERVICE_SECRET,
+        'x-user-id': String(userId),
+      },
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.error || 'Failed to destroy sandbox');
+    return data;
+  },
+
+  /**
+   * Execute a command in the user's sandbox.
+   */
+  async exec(userId, command, opts = {}) {
+    return sandboxFetch('/api/exec', userId, {
+      command,
+      cwd: opts.cwd,
+      timeout: opts.timeout,
+      userKeys: opts.userKeys,
+    });
+  },
+
+  /**
+   * Read a file from the user's sandbox.
+   */
+  async readFile(userId, filePath) {
+    return sandboxFetch('/api/file/read', userId, { filePath });
+  },
+
+  /**
+   * Write a file to the user's sandbox.
+   */
+  async writeFile(userId, filePath, content) {
+    return sandboxFetch('/api/file/write', userId, { filePath, content });
+  },
+
+  /**
+   * Get file tree from the user's sandbox.
+   */
+  async getFileTree(userId, dirPath, depth = 3) {
+    return sandboxFetch('/api/file/tree', userId, { dirPath, depth });
+  },
+
+  /**
+   * Run a git command in the user's sandbox.
+   */
+  async gitOperation(userId, gitCommand, cwd) {
+    return sandboxFetch('/api/git', userId, { gitCommand, cwd });
+  },
+
+  /**
+   * Get the WebSocket URL for an interactive shell session.
+   */
+  getShellWsUrl(userId, sessionId) {
+    const wsBase = SANDBOX_SERVICE_URL.replace(/^http/, 'ws');
+    return `${wsBase}/shell?secret=${encodeURIComponent(SANDBOX_SERVICE_SECRET)}&userId=${userId}&sessionId=${sessionId || 'default'}`;
+  },
+};
+
+export { sandboxClient, SANDBOX_SERVICE_URL };