tide-commander 1.92.0 → 1.93.0

package/dist/src/packages/server/integrations/whatsapp/whatsapp-trigger-handler.js

@@ -16,6 +16,7 @@ import { GroupNameCache } from './group-name-cache.js';
 import { WhatsAppClient } from './whatsapp-client.js';
 import { createLogger } from '../../utils/logger.js';
 import { downloadAttachment, formatAttachmentLine, MAX_ATTACHMENT_BYTES } from '../../services/attachment-downloader.js';
+import { isWhisperAvailable, transcribeAudio } from '../../services/audio-transcription.js';
 import * as crypto from 'crypto';
 const log = createLogger('WhatsAppTrigger');
 // Module-level subscriber set fed by the in-process bridge whenever a normalized
@@ -137,7 +138,12 @@ export function createWhatsAppTriggerHandler(ctx) {
         if (msg.type === 'event' && (msg.event === 'message' || msg.event === 'message_create')) {
             const messageId = extractMessageId(msg.data);
             if (dedupe.isDuplicate(msg.sessionId, messageId)) {
-                // Silent drop — duplicates are expected (upstream dual-fire).
+                // Duplicates are expected (upstream dual-fires `message_create`
+                // immediately followed by `message` for inbound DMs). Log at debug
+                // with the messageId hash so we can confirm in production when
+                // diagnosing rate-limit spikes — otherwise we silently drop and the
+                // operator has no visibility into how many duplicates are happening.
+                log.debug(`dedup.drop session=${msg.sessionId} event=${msg.event} messageId=${messageId ?? 'unknown'}`);
                 return;
             }
             const config = loadConfig();
@@ -265,6 +271,24 @@ export function createWhatsAppTriggerHandler(ctx) {
                             detail: String(err),
                         };
                     }
+                    // Audio → whisper transcription. Runs inline so the trigger
+                    // template renders with the transcription present (otherwise
+                    // bolba/agents would fire with the audio file but no text). We
+                    // gate on `mediaType==='audio'` (covers audioMessage / pttMessage
+                    // / voiceNoteMessage via classifyFlatType) AND on whisper being
+                    // installed — config.transcribeAudio defaults true but the probe
+                    // is the real cutoff so machines without whisper just no-op.
+                    if (payload.mediaType === 'audio' &&
+                        payload.attachment &&
+                        config.transcribeAudio !== false &&
+                        (await isWhisperAvailable())) {
+                        const text = await transcribeAudio(payload.attachment.path, {
+                            model: config.whisperModel || 'medium',
+                            language: config.whisperLanguage?.trim() || undefined,
+                        });
+                        if (text)
+                            payload.audioTranscription = text;
+                    }
                 })()
                 : Promise.resolve();
             void Promise.all([contactPromise, groupPromise, mediaPromise]).then(() => {
@@ -387,27 +411,27 @@ function extractContent(envelope, message) {
     const directMediaType = normalizeMediaType(pickString(envelope.mediaType) ?? pickString(envelope.type));
     const directMediaUrl = pickString(envelope.mediaUrl) ??
         pickString(envelope.media?.url);
-    // 1a. The Baileys upstream we ship today emits a *flat* event shape where
-    // the media signal lives at `data.type` (e.g. "imageMessage") with no
-    // nested `message.imageMessage` proto, no `mediaUrl`, and `media: null`.
-    // Detect that case and surface mediaType so the downloader's
-    // `${baseUrl}/api/sessions/<sid>/messages/<mid>/media?download=true` URL
-    // gets constructed from sessionId+messageId. mimetype/filename/size are
-    // intentionally left undefined here — the downloader fills them from the
-    // proxy's response headers (Content-Type, Content-Disposition).
+    // 1a. Flat-event detection for the Baileys upstream we ship today. Triggers
+    // when EITHER:
+    //   (a) `data.hasMedia === true` (the upstream's explicit "has media" flag),
+    //       OR
+    //   (b) `data.type` is in a tight allowlist of known media-bearing Baileys
+    //       proto names.
     //
-    // Trigger conditions, in priority order:
-    //   1. `data.type` matches `*Message` (image/video/audio/document/sticker
-    //      and all known variants like pttMessage, documentWithCaptionMessage,
-    //      videoNoteMessage, etc.)
-    //   2. `data.hasMedia === true` regardless of how `data.type` is spelled.
-    // We default unknown variants to `document` (the catch-all "it's a file"
-    // category) so the download proceeds; the UI chip picks an icon from the
-    // mimetype the downloader fills in.
-    const flatType = pickString(envelope.type);
+    // We need both because the upstream isn't fully consistent: some media
+    // types arrive with `hasMedia: true` (images observed in the wild), others
+    // arrive with only the `type` field set and no `hasMedia` at all (documents
+    // in the regression David flagged on 2026-05-13).
+    //
+    // The allowlist is precise — it EXCLUDES text/non-media types
+    // (`extendedTextMessage`, `conversation`, `protocolMessage`,
+    // `senderKeyDistributionMessage`, `reactionMessage`, …) that bit us with
+    // the earlier `/Message$/` suffix matcher: those produced bogus
+    // `[attachment-skipped: fetch-failed]` markers for plain text messages.
     const flatHasMedia = pickBoolean(envelope.hasMedia) === true;
-    const flatTypeIsMessage = !!flatType && /Message$/i.test(flatType);
-    if (flatTypeIsMessage || (flatHasMedia && !directMediaType && !directMediaUrl)) {
+    const flatType = pickString(envelope.type);
+    const flatTypeIsKnownMedia = !!flatType && KNOWN_MEDIA_TYPES.has(flatType);
+    if ((flatHasMedia || flatTypeIsKnownMedia) && !directMediaType && !directMediaUrl) {
         return {
             body: directBody,
             mediaType: classifyFlatType(flatType),
@@ -533,6 +557,25 @@ function normalizeMediaType(value) {
         return v;
     return undefined;
 }
+/**
+ * Tight allowlist of Baileys proto names that genuinely carry media bytes.
+ * Excludes text/control events (`extendedTextMessage`, `conversation`,
+ * `protocolMessage`, `senderKeyDistributionMessage`, `reactionMessage`, …)
+ * which were the false positives that broke text messages when we used a
+ * loose `/Message$/` suffix check. If the upstream emits a new media kind
+ * not in this list, add it here.
+ */
+const KNOWN_MEDIA_TYPES = new Set([
+    'imageMessage',
+    'videoMessage',
+    'audioMessage',
+    'documentMessage',
+    'documentWithCaptionMessage',
+    'stickerMessage',
+    'pttMessage',
+    'videoNoteMessage',
+    'voiceNoteMessage',
+]);
 /**
  * Map an upstream `data.type` (Baileys-style, suffixed `Message`) to one of
  * the supported MediaType buckets. Known variants:
@@ -755,6 +798,9 @@ export const whatsappTriggerHandler = {
         // Build the attachments block (single line — WA messages carry at most one
         // media payload). Use the downloaded local path when present; otherwise
         // emit a `[attachment-skipped: …]` marker if we tried and failed.
+        // When an audio transcription is available we append it on its own line
+        // so existing templates referencing `{{whatsapp.attachmentsBlock}}` see
+        // both the file chip and the spoken text without any template edits.
         let attachmentsBlock = '';
         if (msg.attachment) {
             attachmentsBlock = formatAttachmentLine(msg.attachment);
@@ -764,6 +810,10 @@ export const whatsappTriggerHandler = {
             const sizeMb = typeof sk.size === 'number' ? `${Math.round(sk.size / (1024 * 1024))}MB` : 'unknown';
             attachmentsBlock = `[attachment-skipped: ${sk.reason} name=${sk.filename ?? 'unknown'} size=${sizeMb}${sk.detail ? ` detail=${sk.detail}` : ''}]`;
         }
+        if (msg.audioTranscription) {
+            const tline = `[audio transcription: ${msg.audioTranscription}]`;
+            attachmentsBlock = attachmentsBlock ? `${attachmentsBlock}\n${tline}` : tline;
+        }
         return {
             'whatsapp.from': msg.from,
             'whatsapp.fromName': fromName,
@@ -782,6 +832,10 @@ export const whatsappTriggerHandler = {
             'whatsapp.attachmentName': msg.attachment?.filename ?? msg.mediaFilename ?? '',
             'whatsapp.attachmentSize': msg.attachment ? String(msg.attachment.size) : (msg.mediaSize !== undefined ? String(msg.mediaSize) : ''),
             'whatsapp.attachmentsBlock': attachmentsBlock,
+            // Whisper transcription for audio messages. Empty string when
+            // transcription was disabled, whisper is missing, or the audio failed
+            // to transcribe — never undefined so template substitution is clean.
+            'whatsapp.audioTranscription': msg.audioTranscription ?? '',
             'whatsapp.timestamp': new Date(msg.timestamp).toISOString(),
         };
     },
@@ -805,6 +859,9 @@ export const whatsappTriggerHandler = {
         else if (msg.mediaType) {
             mediaSuffix = `\n[${msg.mediaType} attachment${msg.mediaUrl ? ` ${msg.mediaUrl}` : ''}]`;
         }
+        if (msg.audioTranscription) {
+            mediaSuffix += `\n[audio transcription: ${msg.audioTranscription}]`;
+        }
         return `WhatsApp message ${verb} in ${channel}\nFrom: ${sender}\nSession: ${msg.sessionId}\nTime: ${new Date(msg.timestamp).toISOString()}\n\n${msg.body}${mediaSuffix}`;
     },
 };

package/dist/src/packages/server/routes/files.js

@@ -786,6 +786,47 @@ router.post('/rename', (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+// POST /api/files/create - Create a new file or folder inside a target directory
+router.post('/create', (req, res) => {
+    try {
+        const { parentDir, name, isDirectory } = req.body;
+        const validatedParent = parentDir && ensureAbsoluteExistingPath(parentDir);
+        if (!validatedParent) {
+            res.status(400).json({ error: 'Invalid or missing parent directory' });
+            return;
+        }
+        const parentStats = fs.statSync(validatedParent);
+        if (!parentStats.isDirectory()) {
+            res.status(400).json({ error: 'Parent path is not a directory' });
+            return;
+        }
+        const nextName = (name || '').trim();
+        if (!nextName || nextName === '.' || nextName === '..') {
+            res.status(400).json({ error: 'Invalid name' });
+            return;
+        }
+        if (nextName.includes('/') || nextName.includes('\\')) {
+            res.status(400).json({ error: 'Name must not contain path separators' });
+            return;
+        }
+        const destinationPath = path.join(validatedParent, nextName);
+        if (fs.existsSync(destinationPath)) {
+            res.status(409).json({ error: 'Target already exists' });
+            return;
+        }
+        if (isDirectory) {
+            fs.mkdirSync(destinationPath);
+        }
+        else {
+            fs.writeFileSync(destinationPath, '', { flag: 'wx' });
+        }
+        res.json({ success: true, path: destinationPath, isDirectory: !!isDirectory });
+    }
+    catch (err) {
+        log.error(' Failed to create path:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
 // POST /api/files/copy - Copy file/folder into target directory
 router.post('/copy', (req, res) => {
     try {
@@ -2861,10 +2902,10 @@ router.post('/git-fetch', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
-// POST /api/files/delete - Delete a file from disk
+// POST /api/files/delete - Delete a file or (with recursive: true) a directory
 router.post('/delete', (req, res) => {
     try {
-        const filePath = req.body.path;
+        const { path: filePath, recursive } = req.body;
         if (!filePath || typeof filePath !== 'string') {
             res.status(400).json({ error: 'Missing path parameter' });
             return;
@@ -2879,14 +2920,19 @@ router.post('/delete', (req, res) => {
         }
         const stat = fs.statSync(filePath);
         if (stat.isDirectory()) {
-            res.status(400).json({ error: 'Cannot delete directories' });
-            return;
+            if (!recursive) {
+                res.status(400).json({ error: 'Pass recursive: true to delete directories' });
+                return;
+            }
+            fs.rmSync(filePath, { recursive: true, force: true });
+        }
+        else {
+            fs.unlinkSync(filePath);
         }
-        fs.unlinkSync(filePath);
         res.json({ success: true });
     }
     catch (err) {
-        log.error(' Failed to delete file:', err);
+        log.error(' Failed to delete path:', err);
         res.status(500).json({ error: err.message });
     }
 });

package/dist/src/packages/server/services/audio-transcription.js

@@ -0,0 +1,165 @@
+/**
+ * Audio Transcription Service
+ *
+ * Wraps the OpenAI `whisper` CLI when it's installed on the host, so inbound
+ * audio attachments from integrations (WhatsApp voice notes, Slack audio
+ * uploads, …) can be converted to text in addition to the file itself.
+ *
+ * Design constraints:
+ *  - SAFE NO-OP when whisper is missing. The integration pipeline must keep
+ *    working unchanged on machines without it — the only effect is that
+ *    `audioTranscription` stays undefined.
+ *  - NEVER THROWS. Errors are logged and surfaced as `null`.
+ *  - Whisper detection is cached for the process lifetime; installing or
+ *    removing whisper requires a server restart to re-detect (matches the
+ *    behavior of every other CLI-probe we have).
+ *  - We invoke whisper via `--output_format txt --output_dir <same dir as
+ *    audio>` and read the resulting `<base>.txt` back. Stdout could be
+ *    parsed instead but file-based is simpler and avoids buffering large
+ *    progress logs in memory.
+ */
+import { spawn } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('AudioTranscription');
+let whisperAvailable = null;
+/**
+ * Probe for the `whisper` CLI. Cached after the first call.
+ */
+export async function isWhisperAvailable() {
+    if (whisperAvailable !== null)
+        return whisperAvailable;
+    whisperAvailable = await detectWhisper();
+    return whisperAvailable;
+}
+function detectWhisper() {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn('whisper', ['--help'], { stdio: 'ignore' });
+        }
+        catch {
+            log.debug('whisper not found on PATH; audio transcription disabled');
+            resolve(false);
+            return;
+        }
+        proc.on('error', () => {
+            log.debug('whisper not found on PATH; audio transcription disabled');
+            resolve(false);
+        });
+        proc.on('exit', (code) => {
+            const ok = code === 0;
+            if (ok) {
+                log.log('whisper detected on PATH; audio transcription enabled');
+            }
+            else {
+                log.debug(`whisper --help exited ${code}; audio transcription disabled`);
+            }
+            resolve(ok);
+        });
+    });
+}
+/**
+ * Transcribe an audio file via whisper. Returns the transcribed text, or
+ * `null` on any failure (whisper missing, non-zero exit, timeout, missing
+ * file). Never throws.
+ */
+export async function transcribeAudio(audioPath, opts = {}) {
+    if (!(await isWhisperAvailable()))
+        return null;
+    try {
+        await fs.access(audioPath);
+    }
+    catch {
+        log.warn(`transcribeAudio: file not found ${audioPath}`);
+        return null;
+    }
+    const outputDir = path.dirname(audioPath);
+    const baseName = path.basename(audioPath, path.extname(audioPath));
+    const txtPath = path.join(outputDir, `${baseName}.txt`);
+    // Idempotent cache hit: if a previous run already produced the txt file,
+    // skip the (slow) whisper invocation. Same dedup intent as the attachment
+    // downloader's existingSizeMatches.
+    try {
+        const stat = await fs.stat(txtPath);
+        if (stat.isFile() && stat.size > 0) {
+            const cachedText = (await fs.readFile(txtPath, 'utf-8')).trim();
+            if (cachedText) {
+                log.debug(`transcribeAudio: cache-hit ${txtPath}`);
+                return cachedText;
+            }
+        }
+    }
+    catch { /* no cache, fall through */ }
+    const model = opts.model ?? 'medium';
+    const timeoutMs = opts.timeoutMs ?? 5 * 60_000;
+    const args = [
+        audioPath,
+        '--model', model,
+        '--output_format', 'txt',
+        '--output_dir', outputDir,
+        '--verbose', 'False',
+        // `--fp16 False` keeps the FP16-on-CPU UserWarning out of stderr and
+        // matches what whisper itself falls back to on CPU-only hosts anyway.
+        '--fp16', 'False',
+    ];
+    if (opts.language) {
+        args.push('--language', opts.language);
+    }
+    const started = Date.now();
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn('whisper', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (err) {
+            log.warn(`transcribeAudio: spawn threw: ${err}`);
+            resolve(null);
+            return;
+        }
+        let stderr = '';
+        let killed = false;
+        const timer = setTimeout(() => {
+            killed = true;
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch { /* ignore */ }
+            log.warn(`transcribeAudio: timeout after ${timeoutMs}ms for ${audioPath}`);
+        }, timeoutMs);
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+            if (stderr.length > 8192)
+                stderr = stderr.slice(-4096);
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            log.warn(`transcribeAudio: spawn error: ${err}`);
+            resolve(null);
+        });
+        proc.on('exit', async (code) => {
+            clearTimeout(timer);
+            if (killed) {
+                resolve(null);
+                return;
+            }
+            if (code !== 0) {
+                log.warn(`transcribeAudio: whisper exit ${code} for ${audioPath}: ${stderr.slice(-500)}`);
+                resolve(null);
+                return;
+            }
+            try {
+                const raw = await fs.readFile(txtPath, 'utf-8');
+                const text = raw.trim();
+                const tookSec = ((Date.now() - started) / 1000).toFixed(1);
+                log.log(`transcribed ${audioPath} in ${tookSec}s (${text.length} chars, model=${model}${opts.language ? ` lang=${opts.language}` : ''})`);
+                resolve(text || null);
+            }
+            catch (err) {
+                log.warn(`transcribeAudio: failed to read ${txtPath}: ${err}`);
+                resolve(null);
+            }
+        });
+    });
+}

package/dist/src/packages/server/services/trigger-service.js

@@ -491,9 +491,12 @@ export async function fireTrigger(id, variables, opts) {
         log.error(`Cannot fire unknown trigger: ${id}`);
         return;
     }
-    // Rate limit check
-    if (!checkRateLimit(id)) {
-        log.warn(`Trigger ${trigger.name} rate-limited (>${RATE_LIMIT_MAX}/min)`);
+    // Rate limit check. Per-trigger `rateLimitPerMinute` overrides the global
+    // default (10/min). Set to 0 / negative to disable entirely for this
+    // trigger (used by high-volume local sources like personal WA/Slack).
+    const effectiveLimit = typeof trigger.rateLimitPerMinute === 'number' ? trigger.rateLimitPerMinute : RATE_LIMIT_MAX;
+    if (effectiveLimit > 0 && !checkRateLimit(id, effectiveLimit)) {
+        log.warn(`Trigger ${trigger.name} rate-limited (>${effectiveLimit}/min)`);
         return;
     }
     const startTime = Date.now();
@@ -575,7 +578,7 @@ export async function fireTrigger(id, variables, opts) {
     }
 }
 // ─── Rate Limiting ───
-function checkRateLimit(triggerId) {
+function checkRateLimit(triggerId, limit = RATE_LIMIT_MAX) {
     const now = Date.now();
     let timestamps = rateLimitMap.get(triggerId);
     if (!timestamps) {
@@ -587,7 +590,7 @@ function checkRateLimit(triggerId) {
     while (timestamps.length > 0 && timestamps[0] < cutoff) {
         timestamps.shift();
     }
-    if (timestamps.length >= RATE_LIMIT_MAX) {
+    if (timestamps.length >= limit) {
         return false;
     }
     timestamps.push(now);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.92.0",
+  "version": "1.93.0",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",