@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/server/connectors/signal.ts

@@ -1,9 +1,12 @@
+import { log } from '@/lib/server/logger'
 import { spawn, execSync } from 'child_process'
 import type { ChildProcess } from 'child_process'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, ConnectorIngressResult } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'signal'
+
 const signal: PlatformConnector = {
   async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
     const phoneNumber = connector.config.phoneNumber
@@ -43,16 +46,16 @@ const signal: PlatformConnector = {
 
       daemonProc.stderr?.on('data', (chunk: Buffer) => {
         const msg = chunk.toString().trim()
-        if (msg) console.error(`[signal] stderr: ${msg}`)
+        if (msg) log.error(TAG, `stderr: ${msg}`)
       })
 
       daemonProc.on('exit', (code) => {
         if (!stopped) {
-          console.error(`[signal] daemon exited unexpectedly with code ${code}`)
+          log.error(TAG, `daemon exited unexpectedly with code ${code}`)
         }
       })
 
-      console.log(`[signal] Daemon started in stdio mode for ${phoneNumber}`)
+      log.info(TAG, `Daemon started in stdio mode for ${phoneNumber}`)
     } else if (mode === 'http') {
       // Poll the signal-cli REST API for incoming messages
       const pollInterval = 2000
@@ -74,7 +77,7 @@ const signal: PlatformConnector = {
       }
 
       pollTimer = setInterval(poll, pollInterval)
-      console.log(`[signal] Polling ${httpUrl} for ${phoneNumber} every ${pollInterval}ms`)
+      log.info(TAG, `Polling ${httpUrl} for ${phoneNumber} every ${pollInterval}ms`)
     } else {
       throw new Error(`Unknown signalCliMode: ${mode}. Use 'stdio' or 'http'.`)
     }
@@ -119,7 +122,7 @@ const signal: PlatformConnector = {
           daemonProc.kill('SIGTERM')
           daemonProc = null
         }
-        console.log(`[signal] Connector stopped for ${phoneNumber}`)
+        log.info(TAG, `Connector stopped for ${phoneNumber}`)
       },
     }
   },
@@ -177,7 +180,7 @@ export async function handleSignalEvent(
       )
     }
   } catch (err: any) {
-    console.error(`[signal] Error handling message:`, err.message)
+    log.error(TAG, 'Error handling message:', err.message)
   }
 }
 

package/src/lib/server/connectors/slack.ts

@@ -7,6 +7,9 @@ import { resolveConnectorIngressReply } from './ingress-delivery'
 import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime } from './media'
 import { dedup, errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'slack'
 
 function normalizeSlackEmoji(input: string): string {
   const raw = input.trim().replace(/^:|:$/g, '')
@@ -99,7 +102,7 @@ async function hydrateSlackThreadContext(params: {
     params.inbound.threadPersonaLabel = params.inbound.threadTitle
     params.inbound.threadHistory = history.length ? history : undefined
   } catch (err: unknown) {
-    console.warn(`[slack] Thread context bootstrap failed: ${errorMessage(err)}`)
+    log.warn(TAG, `Thread context bootstrap failed: ${errorMessage(err)}`)
   }
 }
 
@@ -141,7 +144,7 @@ const slack: PlatformConnector = {
         throw new Error('Auth test returned empty — the bot token may be revoked or the app uninstalled')
       }
       botUserId = auth.user_id as string
-      console.log(`[slack] Authenticated as @${auth.user} in workspace "${auth.team}"`)
+      log.info(TAG, `Authenticated as @${auth.user} in workspace "${auth.team}"`)
     } catch (err: any) {
       const hint = err.code === 'slack_webapi_platform_error'
         ? '. Check that your Bot Token (xoxb-...) is correct and the app is installed to the workspace.'
@@ -159,7 +162,7 @@ const slack: PlatformConnector = {
 
     // Catch global errors so they don't become unhandled rejections
     app.error(async (error) => {
-      console.error(`[slack] App error:`, error)
+      log.error(TAG, 'App error:', error)
     })
 
     // Optional: restrict to specific channels
@@ -177,7 +180,7 @@ const slack: PlatformConnector = {
       const channelId = msg.channel
       if (allowedChannels && !allowedChannels.includes(channelId)) return
 
-      console.log(`[slack] Message in ${channelId} from ${msg.user}: ${(msg.text || '').slice(0, 80)}`)
+      log.info(TAG, `Message in ${channelId} from ${msg.user}: ${(msg.text || '').slice(0, 80)}`)
 
       // Get user info for display name
       let senderName = msg.user || 'unknown'
@@ -213,7 +216,7 @@ const slack: PlatformConnector = {
                 continue
               }
             } catch (err: any) {
-              console.warn(`[slack] Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
+              log.warn(TAG, `Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
             }
           }
           media.push({
@@ -262,7 +265,7 @@ const slack: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[slack] Error handling message:`, err.message)
+        log.error(TAG, 'Error handling message:', err.message)
         try {
           await say('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -320,12 +323,12 @@ const slack: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[slack] Error handling mention:`, err.message)
+        log.error(TAG, 'Error handling mention:', err.message)
       }
     })
 
     await app.start()
-    console.log(`[slack] Bot connected (socket mode)`)
+    log.info(TAG, 'Bot connected (socket mode)')
 
     let appStopped = false
 
@@ -423,14 +426,14 @@ const slack: PlatformConnector = {
       async stop() {
         appStopped = true
         await app.stop()
-        console.log(`[slack] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
 
     // Bolt emits 'error' on unrecoverable failures (auth revoked, socket closed permanently)
     app.error(async (error) => {
       const errMsg = error.original?.message || error.message || String(error)
-      console.error(`[slack] App error:`, errMsg)
+      log.error(TAG, 'App error:', errMsg)
       if (appStopped) return
       appStopped = true
       instance.onCrash?.(`Slack error: ${errMsg}`)

package/src/lib/server/connectors/teams.ts

@@ -1,6 +1,9 @@
+import { log } from '@/lib/server/logger'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'teams'
+
 const teams: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
     const pkg = 'botbuilder'
@@ -15,7 +18,7 @@ const teams: PlatformConnector = {
     })
 
     adapter.onTurnError = async (_context: unknown, error: Error) => {
-      console.error(`[teams] Turn error:`, error.message)
+      log.error(TAG, 'Turn error:', error.message)
     }
 
     // Store conversation references for proactive messaging
@@ -49,7 +52,7 @@ const teams: PlatformConnector = {
           if (!reply) return
           await context.sendActivity(reply.visibleText)
         } catch (err: any) {
-          console.error(`[teams] Error handling message:`, err.message)
+          log.error(TAG, 'Error handling message:', err.message)
           try {
             await context.sendActivity('Sorry, I encountered an error processing your message.')
           } catch { /* ignore */ }
@@ -61,8 +64,8 @@ const teams: PlatformConnector = {
     const handlerKey = `__swarmclaw_teams_handler_${connector.id}__`
     ;(globalThis as any)[handlerKey] = processActivity
 
-    console.log(`[teams] Bot registered (appId: ${appId})`)
-    console.log(`[teams] Configure your bot's messaging endpoint to POST to /api/connectors/${connector.id}/webhook`)
+    log.info(TAG, `Bot registered (appId: ${appId})`)
+    log.info(TAG, `Configure your bot's messaging endpoint to POST to /api/connectors/${connector.id}/webhook`)
 
     return {
       connector,
@@ -85,7 +88,7 @@ const teams: PlatformConnector = {
         stopped = true
         delete (globalThis as any)[handlerKey]
         conversationReferences.clear()
-        console.log(`[teams] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
   },

package/src/lib/server/connectors/telegram.ts

@@ -7,6 +7,9 @@ import { resolveConnectorIngressReply } from './ingress-delivery'
 import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime, isAudioMime } from './media'
 import { errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'telegram'
 
 const telegram: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
@@ -20,23 +23,23 @@ const telegram: PlatformConnector = {
 
     // Log all errors
     bot.catch((err) => {
-      console.error(`[telegram] Bot error:`, err.message || err)
+      log.error(TAG, 'Bot error:', err.message || err)
     })
 
     // Delete any existing webhook so long polling works
     await bot.api.deleteWebhook().catch((err) => {
-      console.error('[telegram] Failed to delete webhook:', err.message)
+      log.error(TAG, 'Failed to delete webhook:', err.message)
     })
 
     // Log all incoming updates for debugging
     bot.use(async (ctx, next) => {
-      console.log(`[telegram] Update received: chat=${ctx.chat?.id}, from=${ctx.from?.first_name}, hasText=${!!ctx.message?.text}`)
+      log.info(TAG, `Update received: chat=${ctx.chat?.id}, from=${ctx.from?.first_name}, hasText=${!!ctx.message?.text}`)
       await next()
     })
 
     // Handle /start command (required for new conversations)
     bot.command('start', async (ctx) => {
-      console.log(`[telegram] /start from ${ctx.from?.first_name} (chat=${ctx.chat.id})`)
+      log.info(TAG, `/start from ${ctx.from?.first_name} (chat=${ctx.chat.id})`)
       await ctx.reply('Hello! I\'m ready to chat. Send me a message.')
     })
 
@@ -51,15 +54,15 @@ const telegram: PlatformConnector = {
       // that appear as short bracketed strings like [rr], [e], [read] etc.
       const hasMedia = raw.photo || raw.video || raw.audio || raw.voice || raw.document || raw.animation
       if (!hasMedia && /^\[.{1,5}\]$/.test(text.trim())) {
-        console.log(`[telegram] Ignoring system event from ${ctx.from.first_name}: ${text}`)
+        log.info(TAG, `Ignoring system event from ${ctx.from.first_name}: ${text}`)
         return
       }
 
-      console.log(`[telegram] Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
+      log.info(TAG, `Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
 
       // Filter by allowed chats if configured
       if (allowedChats && !allowedChats.includes(chatId)) {
-        console.log(`[telegram] Skipping — chat ${chatId} not in allowed list: ${allowedChats.join(',')}`)
+        log.info(TAG, `Skipping — chat ${chatId} not in allowed list: ${allowedChats.join(',')}`)
         return
       }
 
@@ -125,7 +128,7 @@ const telegram: PlatformConnector = {
           })
           if (stored) media.push(stored)
         } catch (err: any) {
-          console.warn(`[telegram] Failed to fetch media ${m.fileId}:`, err?.message || String(err))
+          log.warn(TAG, `Failed to fetch media ${m.fileId}:`, err?.message || String(err))
           media.push({
             type: m.type,
             fileName: m.fileName,
@@ -175,7 +178,7 @@ const telegram: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[telegram] Error handling message:`, err.message)
+        log.error(TAG, 'Error handling message:', err.message)
         try {
           await ctx.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -268,7 +271,7 @@ const telegram: PlatformConnector = {
       async stop() {
         botRunning = false
         await bot.stop()
-        console.log(`[telegram] Bot stopped`)
+        log.info(TAG, 'Bot stopped')
       },
     }
 
@@ -277,12 +280,12 @@ const telegram: PlatformConnector = {
       allowed_updates: ['message', 'edited_message'],
       onStart: (botInfo) => {
         botUsername = botInfo.username || ''
-        console.log(`[telegram] Bot started as @${botInfo.username} — polling for updates`)
+        log.info(TAG, `Bot started as @${botInfo.username} — polling for updates`)
       },
     }).catch((err: unknown) => {
       botRunning = false
       const errMsg = errorMessage(err)
-      console.error(`[telegram] Polling stopped with error:`, errMsg)
+      log.error(TAG, 'Polling stopped with error:', errMsg)
       instance.onCrash?.(`Polling stopped: ${errMsg}`)
     })
 

package/src/lib/server/connectors/whatsapp.ts

@@ -1,5 +1,5 @@
 import makeWASocket, {
-  useMultiFileAuthState,
+  useMultiFileAuthState as createMultiFileAuthState,
   DisconnectReason,
   fetchLatestBaileysVersion,
   normalizeMessageContent,
@@ -22,6 +22,9 @@ import { getWhatsAppApprovedSenderIds } from './pairing'
 
 import { DATA_DIR } from '../data-dir'
 import { loadConnectors, loadSettings } from '../storage'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'whatsapp'
 
 const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth')
 const INBOUND_DEDUPE_TTL_MS = 2 * 60 * 1000
@@ -210,7 +213,7 @@ function transcodeToWhatsAppVoiceNote(params: {
     })
     if ((result.status ?? 1) !== 0 || !fs.existsSync(outputPath)) {
       const stderr = (result.stderr || '').trim()
-      console.warn(`[whatsapp] Failed to transcode voice note to opus/ogg${stderr ? `: ${stderr}` : ''}`)
+      log.warn(TAG, `Failed to transcode voice note to opus/ogg${stderr ? `: ${stderr}` : ''}`)
       return null
     }
     return {
@@ -396,7 +399,7 @@ export function clearAuthDir(connectorId: string): void {
   const authDir = path.join(AUTH_DIR, connectorId)
   if (fs.existsSync(authDir)) {
     fs.rmSync(authDir, { recursive: true, force: true })
-    console.log(`[whatsapp] Cleared auth state for connector ${connectorId}`)
+    log.info(TAG, `Cleared auth state for connector ${connectorId}`)
   }
 }
 
@@ -406,7 +409,7 @@ const whatsapp: PlatformConnector = {
     const authDir = path.join(AUTH_DIR, connector.id)
     if (!fs.existsSync(authDir)) fs.mkdirSync(authDir, { recursive: true })
 
-    const { state, saveCreds } = await useMultiFileAuthState(authDir)
+    const { state, saveCreds } = await createMultiFileAuthState(authDir)
     const { version } = await fetchLatestBaileysVersion()
 
     let sock: ReturnType<typeof makeWASocket> | null = null
@@ -463,7 +466,7 @@ const whatsapp: PlatformConnector = {
               sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
             } catch (err: unknown) {
               const errMsg = errorMessage(err)
-              console.warn(`[whatsapp] Image send failed (${errMsg}); retrying as document: ${fName}`)
+              log.warn(TAG, `Image send failed (${errMsg}); retrying as document: ${fName}`)
               sent = await sock.sendMessage(channelId, { document: buf, fileName: fName, mimetype: mime, caption })
             }
           } else if (isAudioMime(mime)) {
@@ -523,7 +526,7 @@ const whatsapp: PlatformConnector = {
         clearReconnectTimer()
         try { sock?.end(undefined) } catch { /* ignore */ }
         sock = null
-        console.log(`[whatsapp] Stopped connector: ${connector.name}`)
+        log.info(TAG, `Stopped connector: ${connector.name}`)
       },
     }
 
@@ -545,7 +548,7 @@ const whatsapp: PlatformConnector = {
 
       const gen = ++socketGen // Capture generation for stale detection
       connectionState = 'connecting'
-      console.log(`[whatsapp] Starting socket gen=${gen} for ${connector.name} (hasCreds=${instance.hasCredentials})`)
+      log.info(TAG, `Starting socket gen=${gen} for ${connector.name} (hasCreds=${instance.hasCredentials})`)
 
       sock = makeWASocket({
         version,
@@ -564,10 +567,10 @@ const whatsapp: PlatformConnector = {
 
         const { connection, lastDisconnect, qr } = update
         if (typeof connection === 'string' && connection) connectionState = connection
-        console.log(`[whatsapp] Connection update gen=${gen}: connection=${connection}, hasQR=${!!qr}`)
+        log.info(TAG, `Connection update gen=${gen}: connection=${connection}, hasQR=${!!qr}`)
 
         if (qr) {
-          console.log(`[whatsapp] QR code generated for ${connector.name}`)
+          log.info(TAG, `QR code generated for ${connector.name}`)
           try {
             instance.qrDataUrl = await QRCode.toDataURL(qr, {
               width: 280,
@@ -575,17 +578,17 @@ const whatsapp: PlatformConnector = {
               color: { dark: '#000000', light: '#ffffff' },
             })
           } catch (err) {
-            console.error('[whatsapp] Failed to generate QR data URL:', err)
+            log.error(TAG, 'Failed to generate QR data URL:', err)
           }
         }
         if (connection === 'close') {
           instance.qrDataUrl = null
           const reason = (lastDisconnect?.error as any)?.output?.statusCode
-          console.log(`[whatsapp] Connection closed: reason=${reason} stopped=${stopped}`)
+          log.info(TAG, `Connection closed: reason=${reason} stopped=${stopped}`)
 
           if (reason === DisconnectReason.loggedOut) {
             // Session invalidated — clear auth and restart to get fresh QR
-            console.log(`[whatsapp] Logged out — clearing auth and restarting for fresh QR`)
+            log.info(TAG, `Logged out — clearing auth and restarting for fresh QR`)
             instance.authenticated = false
             instance.hasCredentials = false
             clearAuthDir(connector.id)
@@ -597,38 +600,38 @@ const whatsapp: PlatformConnector = {
           } else if (reason === 440) {
             // Conflict — another session replaced this one. Do NOT reconnect
             // (reconnecting would create a ping-pong loop with the other session)
-            console.log(`[whatsapp] Session conflict (replaced by another connection) — stopping`)
+            log.info(TAG, `Session conflict (replaced by another connection) — stopping`)
             instance.authenticated = false
             instance.onCrash?.('Session conflict — replaced by another connection')
           } else if (!stopped) {
-            console.log(`[whatsapp] Reconnecting in 3s...`)
+            log.info(TAG, `Reconnecting in 3s...`)
             scheduleReconnect(3000)
           } else {
-            console.log(`[whatsapp] Disconnected permanently`)
+            log.info(TAG, `Disconnected permanently`)
           }
         } else if (connection === 'open') {
           instance.authenticated = true
           instance.hasCredentials = true
           instance.qrDataUrl = null
-          console.log(`[whatsapp] Connected as ${sock?.user?.id}`)
+          log.info(TAG, `Connected as ${sock?.user?.id}`)
         }
       })
 
       sock.ev.on('messages.upsert', async (upsert) => {
         const { messages, type } = upsert
-        console.log(`[whatsapp] messages.upsert gen=${gen}: type=${type}, count=${messages.length}`)
+        log.info(TAG, `messages.upsert gen=${gen}: type=${type}, count=${messages.length}`)
 
         if (gen !== socketGen) {
-          console.log(`[whatsapp] Ignoring stale socket event (gen=${gen}, current=${socketGen})`)
+          log.info(TAG, `Ignoring stale socket event (gen=${gen}, current=${socketGen})`)
           return
         }
         if (type !== 'notify') {
-          console.log(`[whatsapp] Ignoring non-notify upsert type: ${type}`)
+          log.info(TAG, `Ignoring non-notify upsert type: ${type}`)
           return
         }
 
         for (const msg of messages) {
-          console.log(`[whatsapp] Processing message: fromMe=${msg.key.fromMe}, jid=${msg.key.remoteJid}, hasConversation=${!!msg.message?.conversation}, hasExtended=${!!msg.message?.extendedTextMessage}`)
+          log.info(TAG, `Processing message: fromMe=${msg.key.fromMe}, jid=${msg.key.remoteJid}, hasConversation=${!!msg.message?.conversation}, hasExtended=${!!msg.message?.extendedTextMessage}`)
 
           if (msg.key.remoteJid === 'status@broadcast') continue
 
@@ -637,7 +640,7 @@ const whatsapp: PlatformConnector = {
             const now = Date.now()
             const seenAt = seenInboundMessageIds.get(msgId)
             if (typeof seenAt === 'number' && now - seenAt <= INBOUND_DEDUPE_TTL_MS) {
-              console.log(`[whatsapp] Skipping duplicate inbound message id: ${msgId}`)
+              log.info(TAG, `Skipping duplicate inbound message id: ${msgId}`)
               continue
             }
             seenInboundMessageIds.set(msgId, now)
@@ -650,7 +653,7 @@ const whatsapp: PlatformConnector = {
 
           // Skip messages sent by the bot itself (tracked by ID to prevent infinite loops)
           if (msg.key.id && sentMessageIds.has(msg.key.id)) {
-            console.log(`[whatsapp] Skipping own bot reply: ${msg.key.id}`)
+            log.info(TAG, `Skipping own bot reply: ${msg.key.id}`)
             sentMessageIds.delete(msg.key.id) // Clean up
             continue
           }
@@ -662,7 +665,7 @@ const whatsapp: PlatformConnector = {
           const myPhoneNum = sock?.user?.id?.split(':')[0] || ''
           const myLid = sock?.user?.lid?.split(':')[0] || ''
           const isSelfChat = (remoteNum === myPhoneNum) || (remoteHost === 'lid' && (myLid ? remoteNum === myLid : true))
-          console.log(`[whatsapp] Self-chat check: remote=${remoteNum}@${remoteHost}, myPhone=${myPhoneNum}, myLid=${myLid}, isSelf=${isSelfChat}`)
+          log.info(TAG, `Self-chat check: remote=${remoteNum}@${remoteHost}, myPhone=${myPhoneNum}, myLid=${myLid}, isSelf=${isSelfChat}`)
           if (msg.key.fromMe && !isSelfChat) continue
 
           const jid = msg.key.remoteJid || ''
@@ -676,9 +679,9 @@ const whatsapp: PlatformConnector = {
           // Self-chat always passes the filter (it's the bot's own account)
           if (allowedJids?.length && !isSelfChat) {
             const matched = isWhatsAppInboundAllowed({ allowedJids, msg, isSelfChat })
-            console.log(`[whatsapp] JID filter: candidates=${collectWhatsAppAddressCandidates(msg).join(',')}, allowedJids=${allowedJids.join(',')}, matched=${matched}`)
+            log.info(TAG, `JID filter: candidates=${collectWhatsAppAddressCandidates(msg).join(',')}, allowedJids=${allowedJids.join(',')}, matched=${matched}`)
             if (!matched) {
-              console.log(`[whatsapp] Skipping message from non-allowed JID: ${jid}`)
+              log.info(TAG, `Skipping message from non-allowed JID: ${jid}`)
               continue
             }
           }
@@ -712,7 +715,7 @@ const whatsapp: PlatformConnector = {
               })
               media.push(saved)
             } catch (err: any) {
-              console.error(`[whatsapp] Failed to decode media: ${err?.message || String(err)}`)
+              log.error(TAG, `Failed to decode media: ${err?.message || String(err)}`)
               media.push({
                 type: mediaCandidate.kind,
                 fileName: mediaCandidate.payload?.fileName || undefined,
@@ -736,7 +739,7 @@ const whatsapp: PlatformConnector = {
             }) || undefined
           }
 
-          console.log(`[whatsapp] Message from ${inbound.senderName} (${jid}): ${inbound.text.slice(0, 80)}`)
+          log.info(TAG, `Message from ${inbound.senderName} (${jid}): ${inbound.text.slice(0, 80)}`)
 
           try {
             const reply = await resolveConnectorIngressReply(onMessage, inbound)
@@ -758,10 +761,10 @@ const whatsapp: PlatformConnector = {
                 state: 'sent',
               })
             } catch (recordErr: unknown) {
-              console.warn(`[whatsapp] Delivery recording failed (response already sent):`, errorMessage(recordErr))
+              log.warn(TAG, 'Delivery recording failed (response already sent):', errorMessage(recordErr))
             }
           } catch (err: unknown) {
-            console.error(`[whatsapp] Error handling message:`, errorMessage(err))
+            log.error(TAG, 'Error handling message:', errorMessage(err))
             try {
               await sock!.sendMessage(jid, { text: 'Sorry, I encountered an error processing your message.' })
             } catch { /* ignore */ }

package/src/lib/server/credentials/credential-repository.ts

@@ -0,0 +1,7 @@
+export {
+  decryptKey,
+  deleteCredential,
+  encryptKey,
+  loadCredentials,
+  saveCredentials,
+} from '@/lib/server/storage'

package/src/lib/server/embeddings.ts

@@ -1,5 +1,8 @@
 import { loadSettings, loadCredentials, decryptKey } from './storage'
 import { hmrSingleton } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'embeddings'
 
 interface PipelineState {
   instance: unknown
@@ -62,7 +65,7 @@ export async function getEmbedding(text: string): Promise<number[] | null> {
       return await ollamaEmbed(text, model, settings.embeddingEndpoint)
     }
   } catch (err: unknown) {
-    console.error(`[embeddings] Error computing embedding:`, err instanceof Error ? err.message : String(err))
+    log.error(TAG, 'Error computing embedding:', err instanceof Error ? err.message : String(err))
   }
 
   return null

package/src/lib/server/gateways/gateway-profile-repository.ts

@@ -0,0 +1,4 @@
+export {
+  loadGatewayProfiles,
+  saveGatewayProfiles,
+} from '@/lib/server/storage'

package/src/lib/server/link-understanding.ts

@@ -1,6 +1,9 @@
 import * as cheerio from 'cheerio'
 import { dedup } from '@/lib/shared-utils'
 import { truncate } from './session-tools/context'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'link-understanding'
 
 const BARE_LINK_RE = /https?:\/\/\S+/gi
 
@@ -48,7 +51,7 @@ export async function runLinkUnderstanding(message: string): Promise<string[]> {
       }
     } catch (err) {
       // Fail silently for link understanding — don't block the main run
-      console.error(`Link understanding failed for ${url}:`, err)
+      log.error(TAG, `Link understanding failed for ${url}:`, err)
     }
   }
 

package/src/lib/server/memory/memory-abstract.test.ts

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { generateAbstract } from './memory-abstract'
+
+// ---------------------------------------------------------------------------
+// Short content guard
+// ---------------------------------------------------------------------------
+
+describe('generateAbstract', () => {
+  it('returns null for content <= 200 chars', async () => {
+    const short = 'A'.repeat(200)
+    assert.equal(await generateAbstract(short, 'title'), null)
+  })
+
+  it('returns null for empty content', async () => {
+    assert.equal(await generateAbstract('', 'title'), null)
+  })
+
+  it('returns null for content exactly 200 chars', async () => {
+    assert.equal(await generateAbstract('x'.repeat(200)), null)
+  })
+
+  // ---------------------------------------------------------------------------
+  // Fallback abstract
+  // ---------------------------------------------------------------------------
+
+  it('returns fallback (truncated prefix) when LLM import fails', async () => {
+    // generateAbstract uses dynamic import('@/lib/server/build-llm')
+    // In a test environment without the full server, the import will fail
+    // and the catch block returns fallbackAbstract
+    const longContent = 'B'.repeat(250)
+    const result = await generateAbstract(longContent, 'title')
+    // Fallback: first 150 chars + '...'
+    assert.ok(result !== null)
+    assert.equal(result, 'B'.repeat(150) + '...')
+  })
+
+  it('returns content as-is when <= 150 chars and LLM fails', async () => {
+    // This case won't trigger because content <= 200 returns null.
+    // The fallback only runs for content > 200 chars.
+    // For content > 200 but fallback returns first 150 + '...'
+    const content = 'C'.repeat(201)
+    const result = await generateAbstract(content, 'title')
+    assert.ok(result !== null)
+    assert.equal(result, 'C'.repeat(150) + '...')
+  })
+
+  it('fallback does not add ellipsis for content <= 150 chars', async () => {
+    // This is a unit test of the fallback logic itself:
+    // Since generateAbstract returns null for content <= 200,
+    // the fallback truncation (150 + '...') only applies to content > 200.
+    // But the fallbackAbstract function itself handles <= 150 without ellipsis.
+    // We test this indirectly — content of 201 chars gets truncated to 150 + '...'
+    const content = 'D'.repeat(201)
+    const result = await generateAbstract(content)
+    assert.equal(result, 'D'.repeat(150) + '...')
+  })
+})