nothumanallowed 13.5.114 → 13.5.115

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.114",
+  "version": "13.5.115",
   "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": {
@@ -57,6 +57,9 @@
     "check-bundle": "node check-bundle.mjs"
   },
   "dependencies": {
+    "better-sqlite3": "^12.9.0",
+    "imapflow": "^1.3.3",
+    "mailparser": "^3.9.8",
     "ws": "^8.18.0"
   }
 }

package/src/commands/ui.mjs

@@ -707,6 +707,409 @@ export async function cmdUI(args) {
         return;
       }
 
+      // ═══════════════════════════════════════════════════════════════════
+      // IMAP EMAIL CLIENT ROUTES — READ-ONLY IMAP, local SQLite DB
+      // ═══════════════════════════════════════════════════════════════════
+
+      // GET /api/imap/accounts
+      if (method === 'GET' && pathname === '/api/imap/accounts') {
+        try {
+          const { listAccounts } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { accounts: listAccounts() });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/accounts — create account
+      if (method === 'POST' && pathname === '/api/imap/accounts') {
+        try {
+          const body = await parseBody(req);
+          const { createAccount, listAccounts } = await import('../services/email-db.mjs');
+          if (!body.email_address || !body.imap_host || !body.smtp_host || !body.password) {
+            sendJSON(res, 400, { error: 'email_address, imap_host, smtp_host, password required' }); return;
+          }
+          const id = createAccount(body);
+          sendJSON(res, 200, { ok: true, id });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/accounts/update
+      if (method === 'POST' && pathname === '/api/imap/accounts/update') {
+        try {
+          const body = await parseBody(req);
+          const { updateAccount } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          updateAccount(body.id, body);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/accounts/delete
+      if (method === 'POST' && pathname === '/api/imap/accounts/delete') {
+        try {
+          const body = await parseBody(req);
+          const { deleteAccount } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          deleteAccount(body.id);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/sync — trigger incremental sync for an account
+      if (method === 'POST' && pathname === '/api/imap/sync') {
+        try {
+          const body = await parseBody(req);
+          if (!body.accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { syncAccount } = await import('../services/email-imap.mjs');
+          // Run async — respond immediately
+          sendJSON(res, 200, { ok: true, status: 'syncing' });
+          syncAccount(body.accountId).catch(e => console.error('[email:sync]', e.message));
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/messages?accountId=&labelId=&limit=&offset=&search=
+      if (method === 'GET' && pathname === '/api/imap/messages') {
+        try {
+          const accountId = url.searchParams.get('accountId');
+          const labelId   = url.searchParams.get('labelId') || null;
+          const limit     = parseInt(url.searchParams.get('limit') || '50', 10);
+          const offset    = parseInt(url.searchParams.get('offset') || '0', 10);
+          const search    = url.searchParams.get('search') || null;
+          if (!accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { listMessages } = await import('../services/email-db.mjs');
+          const result = listMessages(accountId, labelId, limit, offset, search);
+          sendJSON(res, 200, result);
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/message?id=
+      if (method === 'GET' && pathname === '/api/imap/message') {
+        try {
+          const id = url.searchParams.get('id');
+          if (!id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          const { getMessage, markRead } = await import('../services/email-db.mjs');
+          const msg = getMessage(id);
+          if (!msg) { sendJSON(res, 404, { error: 'not found' }); return; }
+          markRead(id, true);
+          sendJSON(res, 200, { message: msg });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/thread?threadId=&accountId=
+      if (method === 'GET' && pathname === '/api/imap/thread') {
+        try {
+          const threadId = url.searchParams.get('threadId');
+          const accountId = url.searchParams.get('accountId');
+          if (!threadId || !accountId) { sendJSON(res, 400, { error: 'threadId and accountId required' }); return; }
+          const { getThread } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { messages: getThread(threadId, accountId) });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/labels?accountId=
+      if (method === 'GET' && pathname === '/api/imap/labels') {
+        try {
+          const accountId = url.searchParams.get('accountId');
+          if (!accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { listLabels } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { labels: listLabels(accountId) });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/labels/create
+      if (method === 'POST' && pathname === '/api/imap/labels/create') {
+        try {
+          const body = await parseBody(req);
+          const { createLabel } = await import('../services/email-db.mjs');
+          if (!body.accountId || !body.name) { sendJSON(res, 400, { error: 'accountId, name required' }); return; }
+          const id = createLabel(body.accountId, body.name, body.color, body.parentId);
+          sendJSON(res, 200, { ok: true, id });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/labels/update
+      if (method === 'POST' && pathname === '/api/imap/labels/update') {
+        try {
+          const body = await parseBody(req);
+          const { updateLabel } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          updateLabel(body.id, body);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/labels/delete
+      if (method === 'POST' && pathname === '/api/imap/labels/delete') {
+        try {
+          const body = await parseBody(req);
+          const { deleteLabel } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          deleteLabel(body.id);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/labels/assign — add label to message
+      if (method === 'POST' && pathname === '/api/imap/labels/assign') {
+        try {
+          const body = await parseBody(req);
+          const { addMessageToLabel, removeMessageFromLabel } = await import('../services/email-db.mjs');
+          if (!body.messageId || !body.labelId) { sendJSON(res, 400, { error: 'messageId, labelId required' }); return; }
+          if (body.remove) removeMessageFromLabel(body.messageId, body.labelId);
+          else addMessageToLabel(body.messageId, body.labelId);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/mark-read
+      if (method === 'POST' && pathname === '/api/imap/mark-read') {
+        try {
+          const body = await parseBody(req);
+          const { markRead } = await import('../services/email-db.mjs');
+          if (!body.messageId) { sendJSON(res, 400, { error: 'messageId required' }); return; }
+          markRead(body.messageId, body.isRead !== false);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/mark-starred
+      if (method === 'POST' && pathname === '/api/imap/mark-starred') {
+        try {
+          const body = await parseBody(req);
+          const { markStarred } = await import('../services/email-db.mjs');
+          if (!body.messageId) { sendJSON(res, 400, { error: 'messageId required' }); return; }
+          markStarred(body.messageId, body.isStarred !== false);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/mark-all-read
+      if (method === 'POST' && pathname === '/api/imap/mark-all-read') {
+        try {
+          const body = await parseBody(req);
+          const { markAllRead } = await import('../services/email-db.mjs');
+          if (!body.accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const count = markAllRead(body.accountId, body.labelId || null);
+          sendJSON(res, 200, { ok: true, count });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/trash — soft delete (moves to trash label, NEVER touches IMAP)
+      if (method === 'POST' && pathname === '/api/imap/trash') {
+        try {
+          const body = await parseBody(req);
+          const { softDelete } = await import('../services/email-db.mjs');
+          if (!body.messageId) { sendJSON(res, 400, { error: 'messageId required' }); return; }
+          softDelete(body.messageId);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/send — send email via SMTP
+      if (method === 'POST' && pathname === '/api/imap/send') {
+        try {
+          const body = await parseBody(req);
+          const { sendEmail } = await import('../services/email-smtp.mjs');
+          if (!body.accountId || !body.to || !body.subject) {
+            sendJSON(res, 400, { error: 'accountId, to, subject required' }); return;
+          }
+          const result = await sendEmail(body.accountId, body);
+          sendJSON(res, 200, { ok: true, messageId: result.messageId });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/drafts/save
+      if (method === 'POST' && pathname === '/api/imap/drafts/save') {
+        try {
+          const body = await parseBody(req);
+          const { saveDraft } = await import('../services/email-db.mjs');
+          if (!body.accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const id = saveDraft(body.accountId, body);
+          sendJSON(res, 200, { ok: true, id });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/drafts?accountId=
+      if (method === 'GET' && pathname === '/api/imap/drafts') {
+        try {
+          const accountId = url.searchParams.get('accountId');
+          if (!accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { listDrafts } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { drafts: listDrafts(accountId) });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/drafts/delete
+      if (method === 'POST' && pathname === '/api/imap/drafts/delete') {
+        try {
+          const body = await parseBody(req);
+          const { deleteDraft } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          deleteDraft(body.id);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/blocked?accountId=
+      if (method === 'GET' && pathname === '/api/imap/blocked') {
+        try {
+          const accountId = url.searchParams.get('accountId');
+          if (!accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { listBlockedSenders } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { blocked: listBlockedSenders(accountId) });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/blocked/add
+      if (method === 'POST' && pathname === '/api/imap/blocked/add') {
+        try {
+          const body = await parseBody(req);
+          const { blockSender } = await import('../services/email-db.mjs');
+          if (!body.accountId || !body.email) { sendJSON(res, 400, { error: 'accountId, email required' }); return; }
+          blockSender(body.accountId, body.email);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/blocked/remove
+      if (method === 'POST' && pathname === '/api/imap/blocked/remove') {
+        try {
+          const body = await parseBody(req);
+          const { unblockSender } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          unblockSender(body.id);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/rules?accountId=
+      if (method === 'GET' && pathname === '/api/imap/rules') {
+        try {
+          const accountId = url.searchParams.get('accountId');
+          if (!accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { listArchivingRules } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { rules: listArchivingRules(accountId) });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/rules/create
+      if (method === 'POST' && pathname === '/api/imap/rules/create') {
+        try {
+          const body = await parseBody(req);
+          const { createArchivingRule } = await import('../services/email-db.mjs');
+          if (!body.accountId || !body.matchType || !body.matchValue) {
+            sendJSON(res, 400, { error: 'accountId, matchType, matchValue required' }); return;
+          }
+          const id = createArchivingRule(body.accountId, body.matchType, body.matchValue, body.targetLabelId);
+          sendJSON(res, 200, { ok: true, id });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/rules/delete
+      if (method === 'POST' && pathname === '/api/imap/rules/delete') {
+        try {
+          const body = await parseBody(req);
+          const { deleteArchivingRule } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          deleteArchivingRule(body.id);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/signatures?accountId=
+      if (method === 'GET' && pathname === '/api/imap/signatures') {
+        try {
+          const accountId = url.searchParams.get('accountId');
+          if (!accountId) { sendJSON(res, 400, { error: 'accountId required' }); return; }
+          const { listSignatures } = await import('../services/email-db.mjs');
+          sendJSON(res, 200, { signatures: listSignatures(accountId) });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/signatures/create
+      if (method === 'POST' && pathname === '/api/imap/signatures/create') {
+        try {
+          const body = await parseBody(req);
+          const { createSignature } = await import('../services/email-db.mjs');
+          if (!body.accountId || !body.name || !body.content) {
+            sendJSON(res, 400, { error: 'accountId, name, content required' }); return;
+          }
+          const id = createSignature(body.accountId, body.name, body.content, body.isDefault || false);
+          sendJSON(res, 200, { ok: true, id });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // POST /api/imap/signatures/delete
+      if (method === 'POST' && pathname === '/api/imap/signatures/delete') {
+        try {
+          const body = await parseBody(req);
+          const { deleteSignature } = await import('../services/email-db.mjs');
+          if (!body.id) { sendJSON(res, 400, { error: 'id required' }); return; }
+          deleteSignature(body.id);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // GET /api/imap/attachment?messageId=&partId=&accountId=
+      if (method === 'GET' && pathname === '/api/imap/attachment') {
+        try {
+          const messageId = url.searchParams.get('messageId');
+          const partId    = url.searchParams.get('partId');
+          const accountId = url.searchParams.get('accountId');
+          if (!messageId || !accountId) { sendJSON(res, 400, { error: 'messageId, accountId required' }); return; }
+          const { getMessage } = await import('../services/email-db.mjs');
+          const { fetchAttachmentContent } = await import('../services/email-imap.mjs');
+          const msg = getMessage(messageId);
+          if (!msg) { sendJSON(res, 404, { error: 'message not found' }); return; }
+          const att = msg.attachments?.find(a => a.part_id === partId);
+          if (!att) { sendJSON(res, 404, { error: 'attachment not found' }); return; }
+          // Check local cache first
+          const db = (await import('../services/email-db.mjs')).getDb();
+          const cached = db.prepare('SELECT content_blob, content_type FROM email_attachments WHERE id = ?').get(att.id);
+          if (cached?.content_blob) {
+            res.writeHead(200, { 'Content-Type': cached.content_type || 'application/octet-stream', 'Content-Disposition': `attachment; filename="${att.filename || 'attachment'}"` });
+            res.end(cached.content_blob);
+          } else {
+            const result = await fetchAttachmentContent(accountId, msg.imap_folder_path, msg.uid, partId);
+            if (!result) { sendJSON(res, 404, { error: 'could not fetch attachment' }); return; }
+            res.writeHead(200, { 'Content-Type': result.contentType || att.content_type || 'application/octet-stream', 'Content-Disposition': `attachment; filename="${att.filename || 'attachment'}"` });
+            res.end(result.buffer);
+          }
+        } catch (e) { sendJSON(res, 500, { error: e.message }); }
+        logRequest(method, pathname, 200, Date.now() - start); return;
+      }
+
+      // ═══════════════════════════════════════════════════════════════════
+
       // POST /api/contacts — create contact
       if (method === 'POST' && pathname === '/api/contacts') {
         try {

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 = '13.5.114';
+export const VERSION = '13.5.115';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';