bloby-bot 0.24.4 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.24.4",
+  "version": "0.25.0",
   "releaseNotes": [
     "1. new stuff",
     "2. ",

package/shared/config.ts

@@ -3,8 +3,8 @@ import { paths, DATA_DIR } from './paths.js';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
-  mode: 'channel' | 'business';
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode, 'assistant' = personal assistant in conversations */
+  mode: 'channel' | 'business' | 'assistant';
   /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
   admins?: string[];
   /** Active skill for customer-facing mode (folder name in workspace/skills/) */

package/supervisor/channels/manager.ts

@@ -13,6 +13,9 @@
  *            All other messages are ignored — it's the user's personal WhatsApp.
  * - business: Bloby has its own number. Numbers in the admins array get the main
  *             system prompt. Everyone else gets the customer support prompt.
+ * - assistant: Personal assistant in conversations. Self-chat = admin channel.
+ *              Others' messages stored for context. Only responds when the owner
+ *              triggers with @botname in someone else's chat.
  */
 
 import fs from 'fs';
@@ -275,6 +278,21 @@ export class ChannelManager {
     // ── Business mode: filter outgoing (except self-chat) ──
     if (mode === 'business' && fromMe && !isSelfChat) return;
 
+    // ── Assistant mode ──
+    // Self-chat: falls through to debounce (processed as admin)
+    // Others' messages or my untriggered messages: store for context, don't invoke
+    // My messages with @botname trigger: falls through to debounce → agent
+    if (mode === 'assistant' && !(fromMe && isSelfChat)) {
+      // Store every message for context (both mine and theirs)
+      this.storeAssistantContext(channel, sender, senderName, text, fromMe);
+
+      // Only continue if it's me AND the message has the trigger
+      const botName = loadConfig().username || 'bloby';
+      const triggerPattern = new RegExp(`^@${botName}[:\\s]`, 'i');
+      if (!fromMe || !triggerPattern.test(text)) return;
+      // Falls through to debounce → flushDebounce → handleAssistantMessage
+    }
+
     // Debounce: accumulate rapid messages from the same sender
     const debounceKey = `${channel}:${sender}`;
     const existing = this.debounceBuffers.get(debounceKey);
@@ -319,8 +337,8 @@ export class ChannelManager {
     const mode = channelConfig.mode || 'channel';
 
     // Route based on mode and role
-    if (mode === 'channel' || (mode === 'business' && fromMe && isSelfChat)) {
-      // Admin (self-chat in either mode)
+    if (mode === 'channel' || (mode === 'business' && fromMe && isSelfChat) || (mode === 'assistant' && fromMe && isSelfChat)) {
+      // Admin (self-chat in any mode)
       const message: InboundMessage = {
         channel,
         sender: sender.replace(/@.*/, ''),
@@ -331,12 +349,30 @@ export class ChannelManager {
         attachments: attachments.length > 0 ? attachments : undefined,
       };
 
-      const modeLabel = mode === 'channel' ? 'Channel mode | self-chat' : 'Business mode | self-chat | admin';
+      const modeLabel = mode === 'channel' ? 'Channel mode | self-chat'
+        : mode === 'assistant' ? 'Assistant mode | self-chat | admin'
+        : 'Business mode | self-chat | admin';
       log.info(`[channels] ${modeLabel} | "${combinedText.slice(0, 60)}"`);
       await this.handleAdminMessage(message);
       return;
     }
 
+    // Assistant mode — triggered message in someone else's chat
+    if (mode === 'assistant') {
+      const message: InboundMessage = {
+        channel,
+        sender: sender.replace(/@.*/, ''),
+        senderName,
+        role: 'assistant',
+        text: combinedText,
+        rawSender: sender,
+        attachments: attachments.length > 0 ? attachments : undefined,
+      };
+      log.info(`[channels] Assistant mode | triggered in chat with ${message.sender} | "${combinedText.slice(0, 60)}"`);
+      await this.handleAssistantMessage(message, channelConfig);
+      return;
+    }
+
     // Business mode — incoming message
     const role = this.resolveBusinessRole(channelConfig, sender);
 
@@ -637,6 +673,159 @@ export class ChannelManager {
     );
   }
 
+  /** Store a message in the assistant context buffer (for conversation history when triggered) */
+  private storeAssistantContext(
+    channel: ChannelType,
+    sender: string,
+    senderName: string | undefined,
+    text: string,
+    fromMe: boolean,
+  ) {
+    const bufferKey = `${channel}:${sender}`;
+    let buffer = this.customerBuffers.get(bufferKey);
+    if (!buffer) {
+      buffer = [];
+      this.customerBuffers.set(bufferKey, buffer);
+    }
+    const label = fromMe ? 'me' : (senderName || sender.replace(/@.*/, ''));
+    buffer.push({ role: 'user', content: `[${label}]: ${text}` });
+    if (buffer.length > MAX_BUFFER_MESSAGES) {
+      buffer.splice(0, buffer.length - MAX_BUFFER_MESSAGES);
+    }
+  }
+
+  /** Handle a triggered assistant message — runs one-shot agent with conversation context */
+  private async handleAssistantMessage(msg: InboundMessage, channelConfig: ChannelConfig) {
+    const agentKey = `${msg.channel}:${msg.sender}`;
+
+    // Check concurrent limit
+    if (this.activeAgents.size >= MAX_CONCURRENT_AGENTS && !this.activeAgents.has(agentKey)) {
+      log.info(`[channels] Max concurrent agents reached — queuing assistant message for ${msg.sender}`);
+      this.messageQueue.push(msg);
+      return;
+    }
+
+    const { workerApi, getModel } = this.opts;
+    const model = getModel();
+
+    // Strip trigger prefix: "@bloby: do X" → "do X"
+    const config = loadConfig();
+    const botName = config.username || 'bloby';
+    const triggerRegex = new RegExp(`^@${botName}[:\\s]+`, 'i');
+    const cleanText = msg.text.replace(triggerRegex, '').trim();
+
+    // Load SCRIPT.md from configured skill
+    const scriptPrompt = this.loadActiveScript(channelConfig);
+
+    // Fetch agent name
+    let agentBotName = 'Bloby', humanName = 'Human';
+    try {
+      const status = await workerApi('/api/onboard/status');
+      agentBotName = status.agentName || 'Bloby';
+      humanName = status.userName || 'Human';
+    } catch {}
+
+    // Get conversation buffer (already populated by storeAssistantContext)
+    let buffer = this.customerBuffers.get(agentKey);
+    if (!buffer) {
+      buffer = [];
+      this.customerBuffers.set(agentKey, buffer);
+    }
+
+    // All buffered messages are context for the agent
+    const recentMessages: RecentMessage[] = buffer.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    // Load per-contact memory from the skill's customer_data directory
+    let contactMemory = '';
+    try {
+      const customerDataDir = this.getSkillCustomerDataDir(channelConfig);
+      if (customerDataDir) {
+        const memoryPath = path.join(WORKSPACE_DIR, customerDataDir, `${msg.sender}.md`);
+        if (fs.existsSync(memoryPath)) {
+          contactMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
+        }
+      }
+    } catch {}
+
+    // Build enriched script with contact memory
+    let enrichedScript = scriptPrompt;
+    if (contactMemory && enrichedScript) {
+      enrichedScript += `\n\n---\n# Contact History (${msg.sender})\n\n${contactMemory}`;
+    }
+
+    const channelContext = `[WhatsApp | ${msg.sender} | assistant${msg.senderName ? ` | ${msg.senderName}` : ''}]\n`;
+
+    // Convert inbound attachments to agent format
+    const agentAttachments: AgentAttachment[] | undefined = msg.attachments?.map((att) => ({
+      type: 'image' as const,
+      name: `whatsapp_image.${att.mediaType.split('/')[1] || 'jpg'}`,
+      mediaType: att.mediaType,
+      data: att.data,
+    }));
+
+    // Stable convId per contact
+    const convId = `channel-${agentKey}`;
+
+    this.activeAgents.set(agentKey, { sender: msg.sender, channel: msg.channel });
+
+    // Show "typing..." while the agent processes
+    this.startTyping(msg.channel, msg.rawSender);
+
+    // Track text chunks for WhatsApp
+    let waChunkBuf = '';
+
+    startBlobyAgentQuery(
+      convId,
+      channelContext + cleanText,
+      model,
+      (type, eventData) => {
+        // Accumulate text tokens
+        if (type === 'bot:token' && eventData.token) {
+          waChunkBuf += eventData.token;
+        }
+
+        // Agent paused to use a tool — send accumulated text as intermediate message
+        if (type === 'bot:tool' && waChunkBuf.trim()) {
+          this.sendMessage(msg.channel, msg.rawSender, waChunkBuf.trim()).catch((err) => {
+            log.warn(`[channels] Failed to send assistant chunk: ${err.message}`);
+          });
+          waChunkBuf = '';
+        }
+
+        if (type === 'bot:response' && eventData.content) {
+          // Add response to buffer for continuity across triggers
+          buffer!.push({ role: 'assistant', content: eventData.content });
+          if (buffer!.length > MAX_BUFFER_MESSAGES) {
+            buffer!.splice(0, buffer!.length - MAX_BUFFER_MESSAGES);
+          }
+
+          // Send remaining text
+          const remaining = waChunkBuf.trim();
+          if (remaining) {
+            this.sendMessage(msg.channel, msg.rawSender, remaining).catch((err) => {
+              log.warn(`[channels] Failed to send assistant reply: ${err.message}`);
+            });
+            waChunkBuf = '';
+          }
+        }
+
+        if (type === 'bot:done') {
+          this.activeAgents.delete(agentKey);
+          if (eventData.usedFileTools) this.opts.restartBackend();
+          this.processQueue();
+        }
+      },
+      agentAttachments,
+      undefined,
+      { botName: agentBotName, humanName },
+      recentMessages,
+      enrichedScript,
+    );
+  }
+
   /** Transcribe audio via the existing whisper endpoint */
   private async transcribeAudio(audioBase64: string): Promise<string | null> {
     try {

package/supervisor/channels/types.ts

@@ -3,12 +3,12 @@
  */
 
 export type ChannelType = 'whatsapp' | 'telegram';
-export type SenderRole = 'admin' | 'customer';
+export type SenderRole = 'admin' | 'customer' | 'assistant';
 
 export interface ChannelConfig {
   enabled: boolean;
-  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode */
-  mode: 'channel' | 'business';
+  /** 'channel' = just talk to me (self-chat only), 'business' = admin/customer mode, 'assistant' = personal assistant in conversations */
+  mode: 'channel' | 'business' | 'assistant';
   /** Phone numbers with admin access (owner, secretary, etc.) — business mode only */
   admins?: string[];
   /** Active skill for customer-facing mode (folder name in workspace/skills/) */

package/workspace/skills/whatsapp/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "whatsapp",
+  "version": "2.0.0",
+  "description": "WhatsApp channel via Baileys. QR auth, messaging, voice transcription, channel and business modes.",
+  "skills": "./"
+}

package/workspace/skills/whatsapp/SKILL.md

@@ -0,0 +1,227 @@
+# WhatsApp
+
+## What This Is
+
+Gives your agent a WhatsApp number. Connect via QR code, send and receive messages, handle voice notes, and switch between personal (channel) and business modes. Built on Baileys — no Meta Business API needed.
+
+## Dependencies
+
+None.
+
+---
+
+## How Responses Work
+
+**Your text response IS the WhatsApp reply.** When you receive a message tagged with `[WhatsApp | ...]`, the supervisor takes whatever you respond with and sends it directly to WhatsApp. You do NOT need to use curl or `/api/channels/send` to reply — just respond normally.
+
+**Do NOT use `/api/channels/send` to reply to incoming WhatsApp messages.** That endpoint is ONLY for proactive messages (during pulse, cron, or when you want to initiate a conversation). If you use it to reply, the person will get duplicate messages.
+
+**Adjust your style for WhatsApp:** Keep messages shorter and more conversational than chat. No markdown headers, no code blocks unless asked. Think texting, not email.
+
+---
+
+## How Messages Arrive
+
+When a message arrives via WhatsApp, the supervisor wraps it with context:
+
+```
+[WhatsApp | 5511999888777 | customer | Alice]
+Hi, I'd like to schedule an appointment.
+```
+
+The format is: `[WhatsApp | phone | role | name (optional)]`
+
+- **role=admin**: This is your human or an authorized admin. Use your normal personality, full capabilities, main system prompt.
+- **role=customer**: This is someone else messaging. Follow the instructions from the active skill's SCRIPT.md (loaded as your system prompt for that conversation).
+- **role=assistant**: Your human triggered you with `@botname:` inside a conversation with this person. You have the full conversation history as context. Execute the task and respond concisely — your reply goes directly into that chat. The SCRIPT.md from the active skill is loaded as your system prompt.
+
+---
+
+## Channel Config
+
+Your channel configuration is injected into your context (if any channels are configured). It comes from `~/.bloby/config.json` — a file OUTSIDE your workspace that the supervisor manages.
+
+---
+
+## Modes
+
+**Channel Mode** (default): Your human's own WhatsApp number. Only self-chat (messages your human sends to themselves) triggers you — messages from other people are completely ignored. This is "just talk to me" mode.
+
+**Business Mode**: Bloby has its own dedicated WhatsApp number. Numbers in the `admins` array get admin access (main system prompt). Everyone else is a customer and gets the support prompt from the active skill's SCRIPT.md.
+
+**Assistant Mode**: Your personal assistant inside your own conversations. Self-chat works as a normal admin channel. When other people message you, their messages are silently stored for context. When YOU type `@botname:` followed by a command in someone's chat, the agent activates with full conversation context and responds in that chat. The trigger uses the bot's configured name (from `config.json` `username` field) and is case-insensitive. Nobody else can trigger the agent — only you (the account owner). Uses the active skill's SCRIPT.md for the system prompt and `customer_data/` for per-contact memory.
+
+---
+
+## Setup
+
+### 1. Connect WhatsApp
+
+When your human asks to configure WhatsApp:
+
+1. Start the connection:
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/connect
+```
+
+2. Tell them to open the QR page: `/api/channels/whatsapp/qr-page`
+   (Send this as a relative URL — their browser is already on the correct domain. Don't mention the URL until you are actually starting the connection)
+
+3. They scan the QR with their WhatsApp app
+
+4. The default mode is **channel** (self-chat only)
+
+If the QR page doesn't load, make sure you initiated the connection first (step 1).
+
+**On mobile?** The QR page also offers a "Link with phone number instead" option. The user enters their phone number, gets an 8-character code, and types it into WhatsApp (Settings > Linked Devices > Link a Device > "Link with phone number instead"). No camera needed.
+
+### 2. Choose a Mode
+
+**Channel mode** (default) — personal assistant. Only self-chat triggers the agent:
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" \
+  -d '{"mode":"channel"}'
+```
+
+**Business mode** — customer-facing. The agent responds to incoming messages from customers using a skill's SCRIPT.md. Admin numbers get full agent access:
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" \
+  -d '{"mode":"business","admins":["ADMIN_PHONE_1","ADMIN_PHONE_2"],"skill":"SKILL_FOLDER_NAME"}'
+```
+
+Replace `ADMIN_PHONE_1` with the human's phone number (digits only, with country code, e.g. `5511999887766`). Replace `SKILL_FOLDER_NAME` with the skill that should handle customer conversations (e.g. `whatsapp-clinic-secretary`).
+
+**Assistant mode** — personal assistant in your conversations. Self-chat works normally. Other people's messages are stored silently. Type `@botname: <command>` in any chat to trigger the agent:
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" \
+  -d '{"mode":"assistant","skill":"SKILL_FOLDER_NAME"}'
+```
+
+The trigger uses the bot's name from `config.json` `username` field (e.g. if username is "bloby", trigger is `@bloby:`). Only the account owner can trigger — other people's messages are context only.
+
+### 3. Verify
+
+```bash
+curl -s http://localhost:7400/api/channels/status
+```
+
+Expected: `"channel":"whatsapp","connected":true`
+
+---
+
+## Business Mode — Active Skill
+
+Only ONE skill can be active for customer-facing mode at a time. The active skill is set in the channel config (`channels.whatsapp.skill`). When your human asks to switch skills:
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" -d '{"skill":"whatsapp-clinic"}'
+```
+
+The active skill should have:
+- `SCRIPT.md` — the customer-facing system prompt (loaded automatically for customer conversations)
+- Optionally a `customer_data/` directory — per-customer memory files (named by phone number, e.g. `5511999887766.md`)
+
+---
+
+## Sending Proactive Messages
+
+To INITIATE a WhatsApp message (during pulse, cron, or when you want to reach out first):
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/send \
+  -H "Content-Type: application/json" \
+  -d '{"channel":"whatsapp","to":"5511999888777","text":"Your appointment is confirmed for tomorrow at 2pm."}'
+```
+
+Phone number format: digits with country code (e.g. `5511999887766`). The system normalizes to WhatsApp JID format automatically.
+
+**Remember:** This is ONLY for starting new conversations or sending unprompted messages. When replying to an incoming message, just respond normally — the supervisor handles delivery.
+
+---
+
+## Customer Conversation Logs
+
+When you finish a conversation with a **customer** via WhatsApp, save a summary to `whatsapp/{phone}.md`:
+- Key details from the conversation
+- Outcome (appointment scheduled, question answered, etc.)
+- Any follow-ups needed
+- Timestamp
+
+This is your memory of that customer. Next time they message, read their file first.
+
+---
+
+## Voice Notes
+
+Voice messages are automatically transcribed via Whisper and delivered as text. No extra setup needed if Whisper is configured on the supervisor.
+
+## Typing Indicator
+
+The agent automatically shows "typing..." to the recipient while composing a response. This is handled by the supervisor — no action needed from you.
+
+## Message Buffering (Business Mode)
+
+In business mode, rapid messages from the same customer are debounced (4-second window) and delivered together. The system maintains a 30-message conversation buffer per customer.
+
+## Concurrent Conversations (Business Mode)
+
+Up to 5 customer conversations can run in parallel. Additional messages queue automatically.
+
+---
+
+## Account Management
+
+**Disconnect** (keep credentials for later):
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/disconnect
+```
+
+**Logout** (delete credentials, requires new QR scan):
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/logout
+```
+
+**Switch accounts** (relink): Use the "Relink" button on the QR page, or logout + connect again.
+
+---
+
+## Human Interaction
+
+- The human must scan the QR code with their phone — this cannot be automated
+- If WhatsApp disconnects (phone lost, account switched), the human needs to re-scan
+- In business mode, explain to the human that admin numbers get full agent access while all other numbers get the customer-facing skill
+- If the human asks about privacy: credentials are stored locally at `~/.bloby/channels/whatsapp/auth/`, never sent to external servers
+
+---
+
+## API Reference
+
+| Endpoint | Method | Purpose |
+|----------|--------|---------|
+| `/api/channels/status` | GET | List all channel statuses |
+| `/api/channels/whatsapp/qr` | GET | Get current QR code SVG |
+| `/api/channels/whatsapp/qr-page` | GET | Standalone QR scanning page |
+| `/api/channels/whatsapp/connect` | POST | Start WhatsApp (triggers QR if needed) |
+| `/api/channels/whatsapp/disconnect` | POST | Disconnect WhatsApp |
+| `/api/channels/whatsapp/logout` | POST | Disconnect + delete credentials |
+| `/api/channels/whatsapp/configure` | POST | Set mode + admins + skill |
+| `/api/channels/whatsapp/pairing-code` | POST | Get 8-char pairing code (mobile linking) |
+| `/api/channels/send` | POST | Send proactive message via channel |
+
+All endpoints use `http://localhost:7400` for internal API calls (curl from your terminal). For URLs shown to your human, use relative paths (e.g. `/api/channels/whatsapp/qr-page`) — their browser is already on the correct domain.
+
+---
+
+## Technical Notes
+
+- Baileys is a reverse-engineering of WhatsApp Web. It can break if WhatsApp changes their protocol. Reconnection is automatic on network drops.
+- If you get error 401 (loggedOut), credentials were invalidated — the human needs to re-scan QR.
+- If you get error 440 (connectionReplaced), another device/instance took over — do NOT auto-reconnect, ask the human.
+- LID (Local ID) vs phone number: WhatsApp uses internal IDs. The system translates them automatically — use phone numbers in all your API calls.

package/workspace/skills/whatsapp/skill.json

@@ -0,0 +1,15 @@
+{
+  "name": "whatsapp",
+  "version": "2.0.0",
+  "type": "skill",
+  "bloby_human": "Bruno Bertapeli",
+  "bloby": "bloby-bruno",
+  "author": "newbot-official",
+  "description": "WhatsApp channel for your agent via Baileys. QR auth, messaging, voice transcription, channel and business modes.",
+  "depends": [],
+  "env_keys": [],
+  "has_telemetry": false,
+  "size": "12KB",
+  "contains_binaries": false,
+  "tags": ["whatsapp", "channel", "messaging"]
+}