nothumanallowed 14.1.57 → 14.1.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "14.1.57",
+  "version": "14.1.59",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '14.1.57';
+export const VERSION = '14.1.59';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/email.mjs

@@ -96,7 +96,92 @@ async function persistGmailMessageToDb(config, msg) {
 }
 
 export function register(router) {
-  // ── Gmail ──────────────────────────────────────────────────────────────
+  // ── Gmail DB-first routes ──────────────────────────────────────────────
+
+  // GET /api/gmail/messages — reads from local SQLite DB (fast, offline)
+  router.get('/api/gmail/messages', async (req, res) => {
+    try {
+      const { SQLITE_AVAILABLE, listMessages } = await import('../../services/email-db.mjs');
+      if (!SQLITE_AVAILABLE) return sendJSON(res, 200, { messages: [], total: 0, dbUnavailable: true });
+
+      const url = new URL(req.url, 'http://localhost');
+      const folder = url.searchParams.get('folder') || 'INBOX';
+      const limit = parseInt(url.searchParams.get('limit') || '50');
+      const offset = parseInt(url.searchParams.get('offset') || '0');
+      const search = url.searchParams.get('search') || '';
+
+      const result = listMessages('google', null, limit, offset, search, folder);
+      sendJSON(res, 200, { messages: result.messages ?? [], total: result.total ?? 0, source: 'db' });
+    } catch (e) { sendJSON(res, 200, { messages: [], total: 0, error: e.message }); }
+  });
+
+  // POST /api/gmail/sync — fetches from Gmail API and saves to local DB
+  router.post('/api/gmail/sync', async (req, res) => {
+    try {
+      const body = await parseBody(req);
+      const config = loadConfig();
+
+      if (!config.google?.clientId && !config.google?.tokens?.access_token) {
+        return sendJSON(res, 200, { synced: 0, authRequired: true });
+      }
+
+      const folder = (body.folder || 'INBOX').toUpperCase();
+      const limit = body.limit || 50;
+
+      const { getAllEmails } = await import('../../services/google-gmail.mjs');
+      const emails = await getAllEmails(config, folder, limit);
+
+      // getAllEmails already calls cacheMessages internally which saves to SQLite DB
+      // Also persist via persistGmailMessageToDb for body_html
+      for (const msg of emails) {
+        await persistGmailMessageToDb(config, msg).catch(() => {});
+      }
+
+      sendJSON(res, 200, { synced: emails.length, folder });
+    } catch (e) {
+      sendJSON(res, 200, { synced: 0, error: e.message });
+    }
+  });
+
+  // GET /api/gmail/message — read single message from DB, fallback to Gmail API
+  router.get('/api/gmail/message', async (req, res) => {
+    try {
+      const url = new URL(req.url, 'http://localhost');
+      const id = url.searchParams.get('id');
+      if (!id) return sendError(res, 400, 'id required');
+
+      // Try DB first
+      const { getMessage: dbGetMessage } = await import('../../services/email-db.mjs');
+      const dbMsg = dbGetMessage(id);
+      if (dbMsg && (dbMsg.body_text || dbMsg.body_html)) {
+        return sendJSON(res, 200, { message: dbMsg, source: 'db' });
+      }
+
+      // Fallback to Gmail API
+      const config = loadConfig();
+      const msg = await getMessage(config, id);
+      if (msg) {
+        persistGmailMessageToDb(config, msg).catch(() => {});
+        return sendJSON(res, 200, {
+          message: {
+            id: msg.id,
+            subject: msg.subject,
+            from_address: msg.from ? (msg.from.match(/<(.+?)>$/)?.[1] || msg.from) : '',
+            from_name: msg.from ? (msg.from.match(/^(.+?)\s*<.+>$/)?.[1]?.replace(/['"]/g, '') || '') : '',
+            to_addresses: msg.to || '',
+            internal_date: msg.date || '',
+            body_text: msg.body || '',
+            body_html: msg.bodyHtml || '',
+            body_preview: msg.snippet || '',
+          },
+          source: 'gmail_api',
+        });
+      }
+      sendJSON(res, 200, { message: null });
+    } catch (e) { sendError(res, 500, e.message); }
+  });
+
+  // ── Gmail legacy ──────────────────────────────────────────────────────
 
   router.get('/api/emails', async (req, res) => {
     try {
@@ -325,12 +410,12 @@ export function register(router) {
       const { listMessages } = await import('../../services/email-db.mjs');
       const url = new URL(req.url, 'http://localhost');
       const accountId = url.searchParams.get('accountId');
-      const folder = url.searchParams.get('folder') || 'INBOX';
+      const labelId = url.searchParams.get('labelId') || null;
+      const folder = url.searchParams.get('folder') || null;
       const limit = parseInt(url.searchParams.get('limit') || '50');
       const offset = parseInt(url.searchParams.get('offset') || '0');
       const search = url.searchParams.get('search') || '';
-      // listMessages(accountId, labelId, limit, offset, search)
-      const result = listMessages(accountId, null, limit, offset, search);
+      const result = listMessages(accountId, labelId, limit, offset, search, folder);
       sendJSON(res, 200, { messages: result.messages ?? result, total: result.total ?? 0 });
     } catch (e) { sendError(res, 500, e.message); }
   });

package/src/services/email-db.mjs

@@ -565,13 +565,13 @@ export function getMessageLabels(messageId) {
 
 // ── MESSAGE QUERIES ────────────────────────────────────────────────────────
 
-export function listMessages(accountId, labelId, limit, offset, search) {
+export function listMessages(accountId, labelId, limit, offset, search, folder) {
   const db = getDb();
   let where = 'm.account_id = ? AND m.permanently_deleted = 0';
   const params = [accountId];
 
   if (labelId) {
-    // Also include messages saved with matching imap_folder_path in case label link was missing
+    // Filter by label — also include messages saved with matching imap_folder_path
     const lbl = db.prepare('SELECT system_type FROM email_labels WHERE id = ?').get(labelId);
     const folderFallback = lbl?.system_type ? lbl.system_type.charAt(0).toUpperCase() + lbl.system_type.slice(1) : null;
     if (folderFallback) {
@@ -581,12 +581,20 @@ export function listMessages(accountId, labelId, limit, offset, search) {
       where += ' AND EXISTS (SELECT 1 FROM email_message_labels j WHERE j.message_id = m.id AND j.label_id = ?)';
       params.push(labelId);
     }
+  } else if (folder) {
+    // Filter by folder path (used by Gmail — messages stored with imap_folder_path like INBOX, SENT, etc.)
+    where += ' AND m.imap_folder_path = ?';
+    params.push(folder.toUpperCase());
   }
   if (search) {
-    where += ' AND (m.subject LIKE ? OR m.from_address LIKE ? OR m.from_name LIKE ? OR m.body_preview LIKE ?)';
+    where += ' AND (m.subject LIKE ? OR m.from_address LIKE ? OR m.from_name LIKE ? OR m.body_preview LIKE ? OR m.body_text LIKE ?)';
     const q = `%${search}%`;
-    params.push(q, q, q, q);
+    params.push(q, q, q, q, q);
   }
+
+  const countWhere = where;
+  const countParams = [...params];
+
   params.push(limit || 50, offset || 0);
 
   const rows = db.prepare(`
@@ -601,7 +609,7 @@ export function listMessages(accountId, labelId, limit, offset, search) {
     LIMIT ? OFFSET ?
   `).all(...params);
 
-  const total = db.prepare(`SELECT COUNT(*) as cnt FROM email_messages m WHERE ${where.replace('LIMIT ? OFFSET ?', '')}`).get(...params.slice(0, -2));
+  const total = db.prepare(`SELECT COUNT(*) as cnt FROM email_messages m WHERE ${countWhere}`).get(...countParams);
 
   return { messages: rows, total: total?.cnt || 0 };
 }

package/src/services/google-gmail.mjs

@@ -353,17 +353,34 @@ function parseMessage(raw) {
   }
 
   let body = '';
+  let bodyHtml = '';
+
+  // Recursive function to find parts in nested multipart structures
+  function findParts(parts) {
+    if (!parts) return;
+    for (const p of parts) {
+      if (p.mimeType === 'text/plain' && p.body?.data && !body) {
+        body = Buffer.from(p.body.data, 'base64url').toString('utf-8');
+      } else if (p.mimeType === 'text/html' && p.body?.data && !bodyHtml) {
+        bodyHtml = Buffer.from(p.body.data, 'base64url').toString('utf-8');
+      } else if (p.parts) {
+        findParts(p.parts);
+      }
+    }
+  }
+
   if (raw.payload?.body?.data) {
-    body = Buffer.from(raw.payload.body.data, 'base64url').toString('utf-8');
+    // Single-part message
+    const content = Buffer.from(raw.payload.body.data, 'base64url').toString('utf-8');
+    if (raw.payload.mimeType === 'text/html') bodyHtml = content;
+    else body = content;
   } else if (raw.payload?.parts) {
-    const textPart = raw.payload.parts.find(p => p.mimeType === 'text/plain');
-    if (textPart?.body?.data) {
-      body = Buffer.from(textPart.body.data, 'base64url').toString('utf-8');
-    }
+    findParts(raw.payload.parts);
   }
 
   // Extract URLs from body
-  const urls = (body.match(/https?:\/\/[^\s<>"']+/g) || []).slice(0, 10);
+  const textContent = body || bodyHtml.replace(/<[^>]+>/g, '');
+  const urls = (textContent.match(/https?:\/\/[^\s<>"']+/g) || []).slice(0, 10);
 
   return {
     id: raw.id,
@@ -373,7 +390,8 @@ function parseMessage(raw) {
     subject: headers.subject || '(no subject)',
     date: headers.date || '',
     snippet: raw.snippet || '',
-    body: body.slice(0, 5000), // cap for LLM context
+    body: body.slice(0, 5000),
+    bodyHtml,
     urls,
     labels: raw.labelIds || [],
     isUnread: (raw.labelIds || []).includes('UNREAD'),
@@ -446,9 +464,9 @@ async function cacheMessages(messages, folder = 'INBOX') {
     const insertStmt = db.prepare(`
       INSERT OR REPLACE INTO email_messages
         (id, account_id, folder_id, imap_folder_path, uid, message_id, thread_id,
-         subject, from_address, from_name, to_addresses, body_text, body_preview,
+         subject, from_address, from_name, to_addresses, body_text, body_html, body_preview,
          internal_date, has_attachments, source)
-      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
     `);
     const stateStmt = db.prepare(`
       INSERT OR REPLACE INTO email_message_state (message_id, is_read, is_starred)
@@ -457,15 +475,15 @@ async function cacheMessages(messages, folder = 'INBOX') {
 
     const insertAll = db.transaction((msgs) => {
       for (const msg of msgs) {
-        const msgId = msg.id; // Use Gmail message ID as primary key (stable, unique)
+        const msgId = msg.id;
         insertStmt.run(
           msgId, googleAccount.id, folderId, folderKey,
-          Date.now() + Math.random() * 1000 | 0, // unique uid
+          Date.now() + Math.random() * 1000 | 0,
           msg.id, msg.threadId || msg.id,
           msg.subject || '(no subject)',
           extractEmail(msg.from), extractName(msg.from),
           msg.to || '',
-          msg.body || '', msg.snippet || '',
+          msg.body || '', msg.bodyHtml || '', msg.snippet || '',
           new Date(msg.date || Date.now()).toISOString(),
           0, 'gmail_api'
         );