bloby-bot 0.26.1 → 0.27.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "bloby-bot",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "releaseNotes": [
-    "1. new stuff",
-    "2. ",
-    "3. ",
+    "1. # voice note (PTT bubble)",
+    "2. # audio file + caption",
+    "3. # PDF",
     "4. "
   ],
   "description": "Self-hosted, self-evolving AI agent with its own dashboard.",

package/supervisor/channels/manager.ts

@@ -175,19 +175,9 @@ export class ChannelManager {
     if (images.length > 0 && provider instanceof WhatsAppChannel) {
       for (const img of images) {
         try {
-          // Resolve file path — try multiple locations since the bot might save anywhere
-          const relPath = img.src.replace(/^\/api\/files\//, '');
-          const candidates = [
-            path.join(WORKSPACE_DIR, 'files', relPath),           // /api/files/images/x.png → workspace/files/images/x.png
-            path.join(WORKSPACE_DIR, relPath),                     // /x.png → workspace/x.png
-            path.join(WORKSPACE_DIR, 'client', 'public', relPath), // /x.png → workspace/client/public/x.png
-          ];
-          const absPath = candidates.find((p) => fs.existsSync(p));
-          if (absPath) {
-            const buffer = fs.readFileSync(absPath);
-            const ext = path.extname(absPath).slice(1);
-            const mimeMap: Record<string, string> = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp' };
-            await provider.sendImage(to, buffer, img.alt || undefined, mimeMap[ext] || 'image/png');
+          const resolved = this.resolveMediaFile(img.src);
+          if (resolved) {
+            await provider.sendImage(to, resolved.buffer, img.alt || undefined, resolved.mimetype);
           } else {
             log.warn(`[channels] Image file not found in any location: ${img.src}`);
           }
@@ -198,6 +188,76 @@ export class ChannelManager {
     }
   }
 
+  /**
+   * Send arbitrary media (audio, image, video, document) via a channel.
+   * Accepts a file path (absolute, workspace-relative, or /api/files/... URL).
+   */
+  async sendMedia(
+    channel: ChannelType,
+    to: string,
+    media: { type: 'audio' | 'image' | 'video' | 'document'; path: string; mimetype?: string; fileName?: string; voiceNote?: boolean },
+    caption?: string,
+  ): Promise<void> {
+    const provider = this.providers.get(channel);
+    if (!provider) throw new Error(`Channel ${channel} not available`);
+
+    const resolved = this.resolveMediaFile(media.path);
+    if (!resolved) throw new Error(`Media file not found: ${media.path}`);
+
+    const mimetype = media.mimetype || resolved.mimetype;
+
+    if (!(provider instanceof WhatsAppChannel)) {
+      throw new Error(`Channel ${channel} does not support media`);
+    }
+
+    switch (media.type) {
+      case 'image':
+        await provider.sendImage(to, resolved.buffer, caption, mimetype);
+        break;
+      case 'audio':
+        await provider.sendAudio(to, resolved.buffer, { mimetype, voiceNote: media.voiceNote });
+        if (caption) await provider.sendMessage(to, caption);
+        break;
+      case 'video':
+        await provider.sendVideo(to, resolved.buffer, caption, mimetype);
+        break;
+      case 'document':
+        await provider.sendDocument(to, resolved.buffer, media.fileName || path.basename(resolved.absPath), mimetype, caption);
+        break;
+      default:
+        throw new Error(`Unsupported media type: ${(media as any).type}`);
+    }
+  }
+
+  /** Resolve a media path (absolute, /api/files/..., or workspace-relative) to buffer + inferred mimetype. */
+  private resolveMediaFile(src: string): { buffer: Buffer; mimetype: string; absPath: string } | null {
+    let absPath: string | undefined;
+
+    if (path.isAbsolute(src) && fs.existsSync(src)) {
+      absPath = src;
+    } else {
+      const relPath = src.replace(/^\/api\/files\//, '').replace(/^\/+/, '');
+      const candidates = [
+        path.join(WORKSPACE_DIR, 'files', relPath),
+        path.join(WORKSPACE_DIR, relPath),
+        path.join(WORKSPACE_DIR, 'client', 'public', relPath),
+      ];
+      absPath = candidates.find((p) => fs.existsSync(p));
+    }
+
+    if (!absPath) return null;
+
+    const buffer = fs.readFileSync(absPath);
+    const ext = path.extname(absPath).slice(1).toLowerCase();
+    const mimeMap: Record<string, string> = {
+      png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp',
+      mp3: 'audio/mpeg', m4a: 'audio/mp4', ogg: 'audio/ogg', opus: 'audio/ogg; codecs=opus', wav: 'audio/wav',
+      mp4: 'video/mp4', mov: 'video/quicktime', webm: 'video/webm',
+      pdf: 'application/pdf', zip: 'application/zip', txt: 'text/plain',
+    };
+    return { buffer, mimetype: mimeMap[ext] || 'application/octet-stream', absPath };
+  }
+
   /** Show "typing..." indicator in a chat */
   startTyping(channel: ChannelType, jid: string): void {
     const provider = this.providers.get(channel);

package/supervisor/channels/whatsapp.ts

@@ -131,6 +131,64 @@ export class WhatsAppChannel implements ChannelProvider {
     log.info(`[whatsapp] Sent image to ${jid} (id=${result?.key?.id || 'unknown'})`);
   }
 
+  /** Send an audio file via WhatsApp. Set voiceNote=true for push-to-talk bubble. */
+  async sendAudio(to: string, audio: Buffer, opts?: { mimetype?: string; voiceNote?: boolean }): Promise<void> {
+    if (!this.sock || !this.connected) {
+      log.warn('[whatsapp] Cannot send audio — not connected');
+      return;
+    }
+    const jid = to.includes('@') ? to : `${to.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+    this.stopTyping(jid);
+
+    const msg: any = {
+      audio,
+      mimetype: opts?.mimetype || 'audio/mpeg',
+      ptt: !!opts?.voiceNote,
+    };
+
+    const result = await this.sock.sendMessage(jid, msg);
+    if (result?.key?.id) this.trackSentId(result.key.id);
+    log.info(`[whatsapp] Sent audio to ${jid} (ptt=${msg.ptt}, mime=${msg.mimetype}, id=${result?.key?.id || 'unknown'})`);
+  }
+
+  /** Send a video via WhatsApp */
+  async sendVideo(to: string, video: Buffer, caption?: string, mimetype?: string): Promise<void> {
+    if (!this.sock || !this.connected) {
+      log.warn('[whatsapp] Cannot send video — not connected');
+      return;
+    }
+    const jid = to.includes('@') ? to : `${to.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+    this.stopTyping(jid);
+
+    const msg: any = { video, mimetype: mimetype || 'video/mp4' };
+    if (caption) msg.caption = caption;
+
+    const result = await this.sock.sendMessage(jid, msg);
+    if (result?.key?.id) this.trackSentId(result.key.id);
+    log.info(`[whatsapp] Sent video to ${jid} (id=${result?.key?.id || 'unknown'})`);
+  }
+
+  /** Send a document (PDF, zip, etc.) via WhatsApp */
+  async sendDocument(to: string, document: Buffer, fileName: string, mimetype?: string, caption?: string): Promise<void> {
+    if (!this.sock || !this.connected) {
+      log.warn('[whatsapp] Cannot send document — not connected');
+      return;
+    }
+    const jid = to.includes('@') ? to : `${to.replace(/[^0-9]/g, '')}@s.whatsapp.net`;
+    this.stopTyping(jid);
+
+    const msg: any = {
+      document,
+      mimetype: mimetype || 'application/octet-stream',
+      fileName,
+    };
+    if (caption) msg.caption = caption;
+
+    const result = await this.sock.sendMessage(jid, msg);
+    if (result?.key?.id) this.trackSentId(result.key.id);
+    log.info(`[whatsapp] Sent document to ${jid} (name=${fileName}, id=${result?.key?.id || 'unknown'})`);
+  }
+
   /** Show "typing..." indicator in a chat. Re-sends every 20s to keep it visible. */
   startTyping(jid: string): void {
     if (!this.sock || !this.connected) return;

package/supervisor/index.ts

@@ -734,19 +734,33 @@ ${!connected ? `<script>
         return;
       }
 
-      // POST /api/channels/send — send a message via any channel
+      // POST /api/channels/send — send a message (and/or media) via any channel
       if (req.method === 'POST' && channelPath === '/api/channels/send') {
         let body = '';
         req.on('data', (chunk: Buffer) => { body += chunk.toString(); });
         req.on('end', async () => {
           try {
-            const { channel, to, text } = JSON.parse(body);
-            if (!channel || !to || !text) {
+            const { channel, to, text, media } = JSON.parse(body);
+            if (!channel || !to) {
               res.writeHead(400);
-              res.end(JSON.stringify({ error: 'Missing channel, to, or text' }));
+              res.end(JSON.stringify({ error: 'Missing channel or to' }));
               return;
             }
-            await channelManager.sendMessage(channel, to, text);
+            if (!text && !media) {
+              res.writeHead(400);
+              res.end(JSON.stringify({ error: 'Missing text or media' }));
+              return;
+            }
+            if (media) {
+              if (!media.type || !media.path) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: 'media requires { type, path }' }));
+                return;
+              }
+              await channelManager.sendMedia(channel, to, media, text);
+            } else {
+              await channelManager.sendMessage(channel, to, text);
+            }
             res.writeHead(200);
             res.end(JSON.stringify({ ok: true }));
           } catch (err: any) {