bloby-bot 0.40.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",

package/supervisor/channels/manager.ts

@@ -116,6 +116,7 @@ export class ChannelManager {
       },
       (status) => this.handleStatusChange(status),
       (audioBase64) => this.transcribeAudio(audioBase64),
+      (fromMe, isSelfChat, isGroup) => this.shouldProcessWhatsAppAudio(fromMe, isSelfChat, isGroup),
     );
     this.providers.set('whatsapp', whatsapp);
 
@@ -140,6 +141,7 @@ export class ChannelManager {
         },
         (status) => this.handleStatusChange(status),
         (audioBase64) => this.transcribeAudio(audioBase64),
+        (fromMe, isSelfChat, isGroup) => this.shouldProcessWhatsAppAudio(fromMe, isSelfChat, isGroup),
       );
       this.providers.set('whatsapp', whatsapp);
       provider = whatsapp;
@@ -419,6 +421,35 @@ export class ChannelManager {
     return config.channels?.[channel];
   }
 
+  /** Decide whether an inbound WhatsApp audio is worth transcribing.
+   *  Mirrors the gates in handleInboundMessage so we don't burn Whisper calls
+   *  (or, worse, leak the bot via "Whisper not enabled" replies) on messages
+   *  that would be filtered out anyway.
+   *
+   *  Audio carries no `@bloby` text trigger, so in assistant mode we only
+   *  transcribe when the audio is admin's self-chat command. */
+  private shouldProcessWhatsAppAudio(fromMe: boolean, isSelfChat: boolean, isGroup: boolean): boolean {
+    const channelConfig = this.getChannelConfig('whatsapp');
+    if (!channelConfig) return false;
+
+    const mode = channelConfig.mode || 'channel';
+
+    // Group gating mirrors handleInboundMessage.
+    if (isGroup) {
+      if (mode === 'channel') return false;
+      if (!channelConfig.allowGroups) return false;
+    }
+
+    if (mode === 'channel') return fromMe && isSelfChat;
+    if (mode === 'assistant') return fromMe && isSelfChat;
+    if (mode === 'business') {
+      // Outbound non-self-chat messages are filtered out — same as handleInboundMessage.
+      if (fromMe && !isSelfChat) return false;
+      return true;
+    }
+    return false;
+  }
+
   /** Handle an incoming message from any channel — debounces rapid messages from the same sender.
    *
    * Per-mode behavior is decided here. To add a new mode: extend the gating block below
@@ -638,14 +669,25 @@ export class ChannelManager {
     const { workerApi, broadcastBloby, getModel } = this.opts;
     const model = getModel();
 
-    // Get or create conversation (shared with chat for mirroring)
+    // Get or create conversation (shared with chat for mirroring).
+    // The current_conversation setting can desync from the DB (e.g. a chat-UI
+    // re-mount writing back a stale cached id, or a conv that was never
+    // persisted in the first place). Verify it actually exists before using it,
+    // otherwise we'd push messages into a ghost conv and FK-fail on every write.
     let convId: string | undefined;
     try {
       const ctx = await workerApi('/api/context/current');
       if (ctx.conversationId) {
-        convId = ctx.conversationId;
-      } else {
+        const verify = await workerApi(`/api/conversations/${ctx.conversationId}/exists`);
+        if (verify?.exists) {
+          convId = ctx.conversationId;
+        } else {
+          log.warn(`[channels] current_conversation=${ctx.conversationId} is stale (no DB row) — creating fresh`);
+        }
+      }
+      if (!convId) {
         const conv = await workerApi('/api/conversations', 'POST', { title: 'WhatsApp', model });
+        if (!conv?.id) throw new Error(`POST /api/conversations returned no id: ${JSON.stringify(conv)}`);
         convId = conv.id;
         await workerApi('/api/context/set', 'POST', { conversationId: convId });
       }
@@ -657,15 +699,20 @@ export class ChannelManager {
     // Use display text for DB/chat (hides enriched agent context from the UI)
     const displayContent = msg.displayText || msg.text;
 
-    // Save user message to DB
+    // Save user message to DB. The worker returns {error,...} on failure
+    // without throwing, so check the response body — silent drops here are
+    // the original cause of "messages not appearing in UI" reports.
     try {
-      await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+      const result = await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
         role: 'user',
         content: displayContent,
         meta: { model, channel: msg.channel },
       });
+      if (result?.error) {
+        log.warn(`[channels] CRITICAL: user message NOT persisted (convId=${convId}): ${result.error}`);
+      }
     } catch (err: any) {
-      log.warn(`[channels] DB persist error: ${err.message}`);
+      log.warn(`[channels] CRITICAL: user message NOT persisted (convId=${convId}): ${err.message}`);
     }
 
     // Broadcast to chat clients (mirroring)
@@ -733,7 +780,13 @@ export class ChannelManager {
             role: 'assistant',
             content: eventData.content,
             meta: { model },
-          }).catch(() => {});
+          }).then((result: any) => {
+            if (result?.error) {
+              log.warn(`[channels] CRITICAL: assistant reply NOT persisted (convId=${convId}): ${result.error}`);
+            }
+          }).catch((err: any) => {
+            log.warn(`[channels] CRITICAL: assistant reply NOT persisted (convId=${convId}): ${err.message}`);
+          });
         }
 
         // Handle turn completion — restart backend if file tools were used,

package/supervisor/channels/whatsapp.ts

@@ -48,6 +48,16 @@ export type OnWhatsAppMessage = (
 /** Callback to transcribe audio via whisper */
 export type TranscribeFn = (audioBase64: string) => Promise<string | null>;
 
+/** Callback that decides whether an audio message warrants transcription.
+ * Returning false makes the channel silently skip the audio (no Whisper call,
+ * no "Whisper not enabled" reply) — used to avoid leaking the bot in modes
+ * where the message would be filtered out downstream anyway. */
+export type ShouldTranscribeAudioFn = (
+  fromMe: boolean,
+  isSelfChat: boolean,
+  isGroup: boolean,
+) => boolean;
+
 export class WhatsAppChannel implements ChannelProvider {
   readonly type: ChannelType = 'whatsapp';
 
@@ -58,6 +68,7 @@ export class WhatsAppChannel implements ChannelProvider {
   private onMessage: OnWhatsAppMessage;
   private onStatusChange: (status: ChannelStatus) => void;
   private transcribe: TranscribeFn | null = null;
+  private shouldTranscribeAudio: ShouldTranscribeAudioFn | null = null;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private intentionalDisconnect = false;
 
@@ -76,10 +87,12 @@ export class WhatsAppChannel implements ChannelProvider {
     onMessage: OnWhatsAppMessage,
     onStatusChange: (status: ChannelStatus) => void,
     transcribe?: TranscribeFn,
+    shouldTranscribeAudio?: ShouldTranscribeAudioFn,
   ) {
     this.onMessage = onMessage;
     this.onStatusChange = onStatusChange;
     this.transcribe = transcribe || null;
+    this.shouldTranscribeAudio = shouldTranscribeAudio || null;
   }
 
   async connect(): Promise<void> {
@@ -441,6 +454,29 @@ export class WhatsAppChannel implements ChannelProvider {
           continue;
         }
 
+        // Resolve sender/chat identity up front so audio gating can consult mode/role.
+        const fromMe = msg.key.fromMe || false;
+        const rawSender = msg.key.remoteJid || '';
+        const participant = msg.key.participant || '';
+        const isGroup = rawSender.endsWith('@g.us');
+
+        // chatJid: where to reply (group JID for groups, peer JID otherwise).
+        const chatJid = rawSender;
+
+        // The actual sender JID:
+        //   - groups: always `participant` (remoteJid is the group)
+        //   - 1:1:   `participant` if Baileys provided one (newer protocol), else remoteJid
+        const actualSender = isGroup
+          ? participant || rawSender
+          : (participant || rawSender);
+
+        // Translate LID JIDs to phone JIDs (only handles our own LID)
+        const sender = this.translateJid(actualSender);
+        const pushName = msg.pushName || undefined;
+
+        // Self-chat: only meaningful for 1:1 — remoteJid is our own number AND no participant.
+        const isSelfChat = !isGroup && !participant && this.ownPhoneJid !== null && this.translateJid(rawSender) === this.ownPhoneJid;
+
         // Extract text — or transcribe audio if it's a voice note
         let rawText = this.extractText(msg.message);
         const images: WhatsAppImageAttachment[] = [];
@@ -459,6 +495,13 @@ export class WhatsAppChannel implements ChannelProvider {
         }
 
         if (!rawText && this.isAudioMessage(msg.message)) {
+          // Mode-aware gate: don't transcribe (and don't reveal the bot with a
+          // "Whisper not enabled" reply) when the message would be filtered out
+          // downstream — e.g. a friend's voice note in assistant mode.
+          if (this.shouldTranscribeAudio && !this.shouldTranscribeAudio(fromMe, isSelfChat, isGroup)) {
+            log.info(`[whatsapp] Audio skipped by mode gate (fromMe=${fromMe}, selfChat=${isSelfChat}, group=${isGroup})`);
+            continue;
+          }
           // Voice note / audio — download and transcribe
           if (!this.transcribe) {
             log.info('[whatsapp] Audio message received but no transcribe function configured — skipping');
@@ -494,28 +537,6 @@ export class WhatsAppChannel implements ChannelProvider {
         // Escape special characters to prevent prompt injection via message content
         const text = this.escapeMessageText(rawText);
 
-        const fromMe = msg.key.fromMe || false;
-        const rawSender = msg.key.remoteJid || '';
-        const participant = msg.key.participant || '';
-        const isGroup = rawSender.endsWith('@g.us');
-
-        // chatJid: where to reply (group JID for groups, peer JID otherwise).
-        const chatJid = rawSender;
-
-        // The actual sender JID:
-        //   - groups: always `participant` (remoteJid is the group)
-        //   - 1:1:   `participant` if Baileys provided one (newer protocol), else remoteJid
-        const actualSender = isGroup
-          ? participant || rawSender
-          : (participant || rawSender);
-
-        // Translate LID JIDs to phone JIDs (only handles our own LID)
-        const sender = this.translateJid(actualSender);
-        const pushName = msg.pushName || undefined;
-
-        // Self-chat: only meaningful for 1:1 — remoteJid is our own number AND no participant.
-        const isSelfChat = !isGroup && !participant && this.ownPhoneJid !== null && this.translateJid(rawSender) === this.ownPhoneJid;
-
         log.info(`[whatsapp] Message from ${sender} (chat=${chatJid}, group=${isGroup}, fromMe=${fromMe}, selfChat=${isSelfChat}, images=${images.length}): ${text.slice(0, 80)}`);
 
         this.onMessage(sender, pushName, text, fromMe, isSelfChat, chatJid, isGroup, images.length > 0 ? images : undefined);

package/supervisor/index.ts

@@ -1325,16 +1325,33 @@ ${!connected ? `<script>
             }
 
             try {
-              // Check if we have an existing conversation for this client
+              // Resolve the conversation id, but verify it exists in the DB
+              // before reusing it. clientConvs and current_conversation can both
+              // hold stale ids (e.g. after a manual DB swap or a chat-UI
+              // re-mount writing back a cached id) — pushing into a ghost conv
+              // FK-fails silently and loses every message.
               let dbConvId = clientConvs.get(ws);
+              if (dbConvId) {
+                const verify = await workerApi(`/api/conversations/${dbConvId}/exists`);
+                if (!verify?.exists) {
+                  log.warn(`[bloby] cached convId ${dbConvId} is stale (no DB row) — discarding`);
+                  dbConvId = undefined;
+                  clientConvs.delete(ws);
+                }
+              }
               if (!dbConvId) {
-                // Check if there's a current conversation set in settings
                 const ctx = await workerApi('/api/context/current');
                 if (ctx.conversationId) {
-                  dbConvId = ctx.conversationId;
-                } else {
-                  // Create a new conversation
+                  const verify = await workerApi(`/api/conversations/${ctx.conversationId}/exists`);
+                  if (verify?.exists) {
+                    dbConvId = ctx.conversationId;
+                  } else {
+                    log.warn(`[bloby] current_conversation=${ctx.conversationId} is stale (no DB row) — creating fresh`);
+                  }
+                }
+                if (!dbConvId) {
                   const conv = await workerApi('/api/conversations', 'POST', { title: content.slice(0, 80), model: freshConfig.ai.model });
+                  if (!conv?.id) throw new Error(`POST /api/conversations returned no id: ${JSON.stringify(conv)}`);
                   dbConvId = conv.id;
                   await workerApi('/api/context/set', 'POST', { conversationId: dbConvId });
                 }
@@ -1353,9 +1370,12 @@ ${!connected ? `<script>
                   type: f.type, name: f.name, mediaType: f.mediaType, filePath: f.relPath,
                 })));
               }
-              await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+              const result = await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
                 role: 'user', content, meta,
               });
+              if (result?.error) {
+                log.warn(`[bloby] CRITICAL: user message NOT persisted (convId=${convId}): ${result.error}`);
+              }
 
               // Broadcast user message to other clients
               broadcastBlobyExcept(ws, 'chat:sync', {
@@ -1467,9 +1487,12 @@ ${!connected ? `<script>
 
                   (async () => {
                     try {
-                      await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+                      const result = await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
                         role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
                       });
+                      if (result?.error) {
+                        log.warn(`[bloby] CRITICAL: assistant reply NOT persisted (convId=${convId}): ${result.error}`);
+                      }
                     } catch (err: any) {
                       log.warn(`[bloby] DB persist bot response error: ${err.message}`);
                     }

package/worker/db.ts

@@ -90,6 +90,9 @@ export function listConversations(limit = 50) {
 export function deleteConversation(id: string) {
   db.prepare('DELETE FROM conversations WHERE id = ?').run(id);
 }
+export function conversationExists(id: string): boolean {
+  return !!db.prepare('SELECT 1 FROM conversations WHERE id = ?').get(id);
+}
 
 // Messages
 export function addMessage(convId: string, role: string, content: string, meta?: { tokens_in?: number; tokens_out?: number; model?: string; audio_data?: string; attachments?: string }) {

package/worker/index.ts

@@ -5,7 +5,7 @@ import path from 'path';
 import { loadConfig, saveConfig } from '../shared/config.js';
 import { paths, WORKSPACE_DIR } from '../shared/paths.js';
 import { log } from '../shared/logger.js';
-import { initDb, closeDb, listConversations, createConversation, deleteConversation, getMessages, addMessage, getSetting, getAllSettings, setSetting, createSession, getSession, deleteExpiredSessions, getRecentMessages, getMessagesBefore, addPushSubscription, removePushSubscription, getAllPushSubscriptions, getPushSubscriptionByEndpoint, createTrustedDevice, getTrustedDevice, updateDeviceLastSeen, listTrustedDevices, deleteTrustedDevice, deleteExpiredDevices, deleteAllTrustedDevices } from './db.js';
+import { initDb, closeDb, listConversations, createConversation, deleteConversation, conversationExists, getMessages, addMessage, getSetting, getAllSettings, setSetting, createSession, getSession, deleteExpiredSessions, getRecentMessages, getMessagesBefore, addPushSubscription, removePushSubscription, getAllPushSubscriptions, getPushSubscriptionByEndpoint, createTrustedDevice, getTrustedDevice, updateDeviceLastSeen, listTrustedDevices, deleteTrustedDevice, deleteExpiredDevices, deleteAllTrustedDevices } from './db.js';
 import webpush from 'web-push';
 import { TOTP } from 'otpauth';
 import QRCode from 'qrcode';
@@ -120,6 +120,9 @@ app.get('/api/conversations/:id', (req, res) => {
   const msgs = getMessages(req.params.id);
   res.json({ id: req.params.id, messages: msgs });
 });
+app.get('/api/conversations/:id/exists', (req, res) => {
+  res.json({ exists: conversationExists(req.params.id) });
+});
 app.post('/api/conversations', (req, res) => {
   const { title, model } = req.body || {};
   const conv = createConversation(title, model);
@@ -128,6 +131,10 @@ app.post('/api/conversations', (req, res) => {
 app.post('/api/conversations/:id/messages', (req, res) => {
   const { role, content, meta } = req.body || {};
   if (!role || !content) { res.status(400).json({ error: 'Missing role or content' }); return; }
+  if (!conversationExists(req.params.id)) {
+    res.status(404).json({ error: 'conversation_not_found', conversationId: req.params.id });
+    return;
+  }
   const msg = addMessage(req.params.id, role, content, meta);
   res.json(msg);
 });