neoagent 2.0.1 → 2.0.2

package/.env.example

@@ -31,3 +31,11 @@ GOOGLE_AI_KEY=your-google-ai-key-here
 #   • Native web_search tool (search the web without driving the browser)
 # Get your key at: https://api.search.brave.com/
 BRAVE_SEARCH_API_KEY=your-brave-search-api-key-here
+
+# Deepgram API key — used for:
+#   • Recordings transcription (Deepgram Nova-3 multilingual via /api/recordings)
+# Without this key: recordings can still be captured and stored, but transcription will fail until retried with a valid key.
+# Get your key at: https://console.deepgram.com/
+DEEPGRAM_API_KEY=your-deepgram-api-key-here
+DEEPGRAM_MODEL=nova-3
+DEEPGRAM_LANGUAGE=multi

package/docs/configuration.md

@@ -26,6 +26,9 @@ At least one API key is required. The active provider and model are configured i
 | `XAI_API_KEY` | Grok (xAI) |
 | `GOOGLE_AI_KEY` | Gemini (Google) |
 | `BRAVE_SEARCH_API_KEY` | Brave Search API for the native `web_search` tool |
+| `DEEPGRAM_API_KEY` | Recordings transcription with Deepgram Nova-3 multilingual |
+| `DEEPGRAM_MODEL` | Deepgram speech model override (defaults to `nova-3`) |
+| `DEEPGRAM_LANGUAGE` | Deepgram language override (defaults to `multi`) |
 | `OLLAMA_URL` | Local Ollama (`http://localhost:11434`) |
 
 ### Messaging

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/db/database.js

@@ -256,6 +256,78 @@ db.exec(`
   CREATE INDEX IF NOT EXISTS idx_health_sync_runs_user ON health_sync_runs(user_id, created_at DESC);
   CREATE INDEX IF NOT EXISTS idx_health_metric_samples_user ON health_metric_samples(user_id, metric_type, updated_at DESC);
   CREATE INDEX IF NOT EXISTS idx_health_metric_samples_time ON health_metric_samples(user_id, start_time DESC, end_time DESC);
+
+  CREATE TABLE IF NOT EXISTS recording_sessions (
+    id TEXT PRIMARY KEY,
+    user_id INTEGER NOT NULL,
+    title TEXT,
+    platform TEXT DEFAULT 'unknown',
+    status TEXT DEFAULT 'recording',
+    transcript_text TEXT,
+    transcript_language TEXT,
+    transcript_model TEXT,
+    started_at TEXT DEFAULT (datetime('now')),
+    ended_at TEXT,
+    duration_ms INTEGER DEFAULT 0,
+    last_error TEXT,
+    metadata_json TEXT DEFAULT '{}',
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+  );
+
+  CREATE TABLE IF NOT EXISTS recording_sources (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    source_key TEXT NOT NULL,
+    source_kind TEXT NOT NULL,
+    media_kind TEXT NOT NULL,
+    mime_type TEXT,
+    status TEXT DEFAULT 'recording',
+    chunk_count INTEGER DEFAULT 0,
+    bytes_received INTEGER DEFAULT 0,
+    duration_ms INTEGER DEFAULT 0,
+    metadata_json TEXT DEFAULT '{}',
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (session_id) REFERENCES recording_sessions(id) ON DELETE CASCADE,
+    UNIQUE(session_id, source_key)
+  );
+
+  CREATE TABLE IF NOT EXISTS recording_chunks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_id TEXT NOT NULL,
+    sequence_index INTEGER NOT NULL,
+    start_ms INTEGER DEFAULT 0,
+    end_ms INTEGER DEFAULT 0,
+    byte_count INTEGER DEFAULT 0,
+    mime_type TEXT,
+    file_path TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (source_id) REFERENCES recording_sources(id) ON DELETE CASCADE,
+    UNIQUE(source_id, sequence_index)
+  );
+
+  CREATE TABLE IF NOT EXISTS recording_transcript_segments (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    source_id TEXT,
+    source_key TEXT,
+    speaker TEXT,
+    text TEXT NOT NULL,
+    start_ms INTEGER DEFAULT 0,
+    end_ms INTEGER DEFAULT 0,
+    confidence REAL,
+    words_json TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (session_id) REFERENCES recording_sessions(id) ON DELETE CASCADE,
+    FOREIGN KEY (source_id) REFERENCES recording_sources(id) ON DELETE CASCADE
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_recording_sessions_user ON recording_sessions(user_id, created_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_recording_sources_session ON recording_sources(session_id, source_key);
+  CREATE INDEX IF NOT EXISTS idx_recording_chunks_source ON recording_chunks(source_id, sequence_index);
+  CREATE INDEX IF NOT EXISTS idx_recording_segments_session ON recording_transcript_segments(session_id, start_ms, created_at);
 `);
 
 try {
@@ -320,6 +392,9 @@ for (const col of [
   "ALTER TABLE conversations ADD COLUMN summary TEXT",
   "ALTER TABLE conversations ADD COLUMN summary_message_count INTEGER DEFAULT 0",
   "ALTER TABLE conversations ADD COLUMN last_summary TEXT",
+  "ALTER TABLE recording_sessions ADD COLUMN transcript_language TEXT",
+  "ALTER TABLE recording_sessions ADD COLUMN transcript_model TEXT",
+  "ALTER TABLE recording_sessions ADD COLUMN duration_ms INTEGER DEFAULT 0",
 ]) {
   try { db.exec(col); } catch { /* column already exists */ }
 }

package/server/http/middleware.js

@@ -61,6 +61,14 @@ function createSessionMiddleware({ secureCookies }) {
 }
 
 function applyHttpMiddleware(app, { secureCookies, sessionMiddleware, validateOrigin }) {
+  const rawRecordingChunkBody = require('express').raw({ limit: '50mb', type: '*/*' });
+  const jsonBody = require('express').json({ limit: '10mb' });
+  const urlencodedBody = require('express').urlencoded({ extended: true });
+  const isRecordingChunkPath = (value = '') => {
+    const path = `${value}`.split('?')[0];
+    return /^\/api\/recordings\/[^/]+\/chunks$/i.test(path);
+  };
+
   if (secureCookies) {
     app.set('trust proxy', 1);
   }
@@ -72,8 +80,24 @@ function applyHttpMiddleware(app, { secureCookies, sessionMiddleware, validateOr
       credentials: true
     })
   );
-  app.use(require('express').json({ limit: '10mb' }));
-  app.use(require('express').urlencoded({ extended: true }));
+  app.use((req, res, next) => {
+    if (isRecordingChunkPath(req.originalUrl || req.url || req.path)) {
+      return rawRecordingChunkBody(req, res, next);
+    }
+    return next();
+  });
+  app.use((req, res, next) => {
+    if (isRecordingChunkPath(req.originalUrl || req.url || req.path)) {
+      return next();
+    }
+    return jsonBody(req, res, next);
+  });
+  app.use((req, res, next) => {
+    if (isRecordingChunkPath(req.originalUrl || req.url || req.path)) {
+      return next();
+    }
+    return urlencodedBody(req, res, next);
+  });
   app.use(sessionMiddleware);
 }
 

package/server/http/routes.js

@@ -15,6 +15,7 @@ const routeRegistry = [
   { basePath: '/api/memory', modulePath: '../routes/memory' },
   { basePath: '/api/scheduler', modulePath: '../routes/scheduler' },
   { basePath: '/api/browser', modulePath: '../routes/browser' },
+  { basePath: '/api/recordings', modulePath: '../routes/recordings' },
   { basePath: '/api/mobile/health', modulePath: '../routes/mobile-health' }
 ];
 

package/server/index.js

@@ -39,6 +39,7 @@ const app = express();
 const httpServer = createServer(app);
 const io = createSocketServer(httpServer, { validateOrigin });
 const sessionMiddleware = createSessionMiddleware({ secureCookies: SECURE_COOKIES });
+const activeSockets = new Set();
 
 setupConsoleInterceptor(io);
 applyHttpMiddleware(app, {
@@ -53,6 +54,98 @@ registerErrorHandler(app);
 
 let shuttingDown = false;
 
+httpServer.on('connection', (socket) => {
+  activeSockets.add(socket);
+  socket.on('close', () => activeSockets.delete(socket));
+});
+
+function closeSocketServer(ioServer, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    if (!ioServer) {
+      resolve();
+      return;
+    }
+
+    let finished = false;
+
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(forceTimer);
+      resolve();
+    };
+
+    const forceTimer = setTimeout(() => {
+      try {
+        ioServer.disconnectSockets(true);
+      } catch (err) {
+        console.error('[Shutdown] Socket.IO force disconnect error:', err.message);
+      }
+      console.warn('[Shutdown] Socket.IO close timed out; forcing client disconnects.');
+      finish();
+    }, timeoutMs);
+
+    forceTimer.unref?.();
+
+    try {
+      ioServer.disconnectSockets(true);
+      ioServer.close(() => finish());
+    } catch (err) {
+      console.error('[Shutdown] Socket.IO close error:', err.message);
+      finish();
+    }
+  });
+}
+
+function closeHttpServer(server, sockets, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    let finished = false;
+
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(forceTimer);
+      resolve();
+    };
+
+    const forceTimer = setTimeout(() => {
+      if (typeof server.closeAllConnections === 'function') {
+        server.closeAllConnections();
+      }
+
+      for (const socket of sockets) {
+        socket.destroy();
+      }
+
+      if (sockets.size > 0) {
+        console.warn(`[Shutdown] Forced ${sockets.size} open socket(s) closed.`);
+      }
+
+      finish();
+    }, timeoutMs);
+
+    forceTimer.unref?.();
+
+    try {
+      server.close((err) => {
+        if (err && err.code !== 'ERR_SERVER_NOT_RUNNING') {
+          console.error('[Shutdown] HTTP server close error:', err.message);
+        }
+        finish();
+      });
+
+      if (typeof server.closeIdleConnections === 'function') {
+        server.closeIdleConnections();
+      }
+    } catch (err) {
+      if (err.code !== 'ERR_SERVER_NOT_RUNNING') {
+        console.error('[Shutdown] HTTP server close threw:', err.message);
+      }
+      finish();
+    }
+  });
+}
+
 async function shutdown() {
   if (shuttingDown) return;
   shuttingDown = true;
@@ -60,12 +153,10 @@ async function shutdown() {
   console.log('Shutting down...');
 
   await stopServices(app);
-
-  try {
-    await new Promise((resolve) => httpServer.close(resolve));
-  } catch {
-    // ignore close races during shutdown
-  }
+  await Promise.allSettled([
+    closeSocketServer(io),
+    closeHttpServer(httpServer, activeSockets),
+  ]);
 
   db.close();
   process.exit(0);

package/server/public/.last_build_id

@@ -1 +1 @@
-fe64fce67ac7f05d4575c0fd7302c732
+e38b9444952230adccfb989891baa8ec