neoagent 2.0.1 → 2.0.3

package/server/routes/recordings.js

@@ -0,0 +1,113 @@
+const express = require('express');
+
+const { requireAuth } = require('../middleware/auth');
+const { sanitizeError } = require('../utils/security');
+
+const router = express.Router();
+
+router.use(requireAuth);
+
+async function readChunkBody(req) {
+  if (Buffer.isBuffer(req.body) && req.body.length > 0) {
+    return req.body;
+  }
+  if (req.readableEnded) {
+    return Buffer.alloc(0);
+  }
+
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+router.get('/', (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const sessions = manager.listSessions(req.session.userId, {
+      limit: Number(req.query.limit) || 24,
+    });
+    res.json(sessions);
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
+router.get('/:sessionId', (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const session = manager.getSession(req.session.userId, req.params.sessionId);
+    res.json({ session });
+  } catch (err) {
+    const message = sanitizeError(err);
+    res.status(/not found/i.test(message) ? 404 : 500).json({ error: message });
+  }
+});
+
+router.post('/', (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const session = manager.createSession(req.session.userId, req.body || {});
+    res.status(201).json({ session });
+  } catch (err) {
+    const message = sanitizeError(err);
+    res.status(/source|title|required|duplicate/i.test(message) ? 400 : 500).json({ error: message });
+  }
+});
+
+router.post('/:sessionId/chunks', async (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const body = await readChunkBody(req);
+    const result = manager.appendChunk(
+      req.session.userId,
+      req.params.sessionId,
+      {
+        sourceKey: req.get('x-recording-source-key') || req.query.sourceKey,
+        sequenceIndex: req.get('x-recording-sequence') || req.query.sequenceIndex,
+        startMs: req.get('x-recording-start-ms') || req.query.startMs,
+        endMs: req.get('x-recording-end-ms') || req.query.endMs,
+        mimeType: req.get('content-type') || req.query.mimeType,
+      },
+      body,
+    );
+    res.status(result.duplicate ? 200 : 201).json(result);
+  } catch (err) {
+    console.error('[Recordings] Chunk upload failed:', err);
+    const message = sanitizeError(err);
+    const status = /not found/i.test(message)
+      ? 404
+      : /empty|required|unknown|non-negative|accepting/i.test(message)
+        ? 400
+        : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+router.post('/:sessionId/finalize', (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const session = manager.finalizeSession(req.session.userId, req.params.sessionId, req.body || {});
+    res.json({ session });
+  } catch (err) {
+    const message = sanitizeError(err);
+    res.status(/not found/i.test(message) ? 404 : 500).json({ error: message });
+  }
+});
+
+router.post('/:sessionId/retry', async (req, res) => {
+  try {
+    const manager = req.app.locals.recordingManager;
+    const session = await manager.retrySession(req.session.userId, req.params.sessionId);
+    res.json({ session });
+  } catch (err) {
+    const message = sanitizeError(err);
+    res.status(/not found/i.test(message) ? 404 : /configured/i.test(message) ? 400 : 500).json({ error: message });
+  }
+});
+
+module.exports = router;

package/server/services/manager.js

@@ -12,6 +12,7 @@ const { MessagingManager } = require('./messaging/manager');
 const { Scheduler } = require('./scheduler/cron');
 const { setupWebSocket } = require('./websocket');
 const { registerMessagingAutomation } = require('./messaging/automation');
+const { RecordingManager } = require('./recordings/manager');
 
 async function startServices(app, io) {
     try {
@@ -55,6 +56,9 @@ async function startServices(app, io) {
 
         messagingManager.restoreConnections().catch(err => console.error('[Messaging] Restore error:', err.message));
 
+        const recordingManager = new RecordingManager(io);
+        app.locals.recordingManager = recordingManager;
+
         const users = db.prepare('SELECT id FROM users').all();
         for (const u of users) {
             mcpClient.loadFromDB(u.id).catch(err => console.error('[MCP] Auto-start error:', err.message));
@@ -77,11 +81,16 @@ async function startServices(app, io) {
             messagingManager,
             mcpClient,
             scheduler,
+            recordingManager,
             memoryManager,
             app
         });
         app.locals.io = io;
 
+        recordingManager.resumePendingSessions().catch((err) => {
+            console.error('[Recordings] Resume error:', err.message);
+        });
+
         console.log('All services initialized');
     } catch (err) {
         console.error('Service init error:', err);

package/server/services/recordings/deepgram.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const DEFAULT_MODEL = process.env.DEEPGRAM_MODEL || 'nova-3';
+const DEFAULT_LANGUAGE = process.env.DEEPGRAM_LANGUAGE || 'multi';
+const DEFAULT_BASE_URL = process.env.DEEPGRAM_BASE_URL || 'https://api.deepgram.com';
+
+function isDeepgramConfigured() {
+  return typeof process.env.DEEPGRAM_API_KEY === 'string' && process.env.DEEPGRAM_API_KEY.trim().length > 0;
+}
+
+async function transcribeChunkWithDeepgram({ audioBytes, mimeType, detectLanguage = DEFAULT_LANGUAGE } = {}) {
+  if (!isDeepgramConfigured()) {
+    throw new Error('DEEPGRAM_API_KEY is not configured.');
+  }
+  if (!(audioBytes instanceof Uint8Array) || audioBytes.byteLength === 0) {
+    throw new Error('Audio payload is empty.');
+  }
+
+  const query = new URLSearchParams({
+    model: DEFAULT_MODEL,
+    language: detectLanguage || DEFAULT_LANGUAGE,
+    punctuate: 'true',
+    smart_format: 'true',
+    paragraphs: 'true',
+    utterances: 'true',
+    diarize: 'false',
+  });
+  const response = await fetch(
+    `${DEFAULT_BASE_URL.replace(/\/$/, '')}/v1/listen?${query.toString()}`,
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Token ${process.env.DEEPGRAM_API_KEY.trim()}`,
+        'Content-Type': mimeType || 'application/octet-stream',
+      },
+      body: audioBytes,
+    },
+  );
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Deepgram request failed (${response.status}): ${body || 'empty response'}`);
+  }
+
+  return response.json();
+}
+
+module.exports = {
+  DEFAULT_LANGUAGE,
+  DEFAULT_MODEL,
+  isDeepgramConfigured,
+  transcribeChunkWithDeepgram,
+};