tide-commander 1.91.0 → 1.93.0

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

@@ -15,6 +15,8 @@ import { ContactNameCache } from './contact-name-cache.js';
 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
@@ -136,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();
@@ -164,7 +171,26 @@ export function createWhatsAppTriggerHandler(ctx) {
                 payload.isGroup &&
                 !payload.groupName &&
                 !!payload.chatId;
-            if (!needsContactEnrich && !needsGroupEnrich) {
+            // Media → download bytes via the upstream proxy (NOT the raw Baileys
+            // `mediaUrl`, which points at an encrypted Meta CDN). The upstream
+            // exposes `/api/sessions/<sid>/messages/<mid>/media?download=true`.
+            //
+            // We download for BOTH directions:
+            //  - inbound (`fromMe=false`): a contact sent media into our number.
+            //  - outbound (`fromMe=true`): the WhatsApp account itself originated
+            //    the media — this is the real-world case where David sends an
+            //    attachment from his own WA so Bolba can process it. The fact that
+            //    Baileys reports `fromMe=true` on messages we ourselves typed in
+            //    the WA app is exactly why filtering on direction was wrong.
+            //
+            // The only case where this is wasteful is Tide Commander itself sending
+            // media via `/api/whatsapp/send-media-url` (upstream echoes back the
+            // `message_create` with `fromMe=true` + mediaType). That's a localhost
+            // self-fetch that costs almost nothing, so we don't bother
+            // distinguishing it from the user-typing case.
+            const needsMediaDownload = !!payload.mediaType &&
+                !!payload.messageId;
+            if (!needsContactEnrich && !needsGroupEnrich && !needsMediaDownload) {
                 ctx.broadcast({ type: 'whatsapp_message', payload });
                 notifyTriggerSubscribers(payload);
                 return;
@@ -189,7 +215,83 @@ export function createWhatsAppTriggerHandler(ctx) {
                     ctx.log.warn(`WhatsApp group lookup failed: ${err}`);
                 })
                 : Promise.resolve();
-            void Promise.all([contactPromise, groupPromise]).then(() => {
+            const mediaPromise = needsMediaDownload
+                ? (async () => {
+                    const apiKey = ctx.secrets.get(WHATSAPP_API_KEY_SECRET);
+                    if (!apiKey) {
+                        payload.skippedAttachment = {
+                            reason: 'fetch-failed',
+                            filename: payload.mediaFilename,
+                            size: payload.mediaSize,
+                            detail: 'whatsapp.apiKey secret missing',
+                        };
+                        return;
+                    }
+                    const base = config.baseUrl.replace(/\/+$/, '');
+                    const downloadUrl = `${base}/api/sessions/${encodeURIComponent(payload.sessionId)}/messages/${encodeURIComponent(payload.messageId)}/media?download=true`;
+                    if (typeof payload.mediaSize === 'number' && payload.mediaSize > MAX_ATTACHMENT_BYTES) {
+                        payload.skippedAttachment = {
+                            reason: 'too-large',
+                            filename: payload.mediaFilename,
+                            size: payload.mediaSize,
+                            sourceUrl: downloadUrl,
+                        };
+                        return;
+                    }
+                    try {
+                        const result = await downloadAttachment({
+                            source: 'whatsapp',
+                            messageId: payload.messageId,
+                            url: downloadUrl,
+                            headers: { 'X-API-Key': apiKey },
+                            suggestedFilename: payload.mediaFilename,
+                            mimetype: payload.mediaMimetype,
+                            sizeHintBytes: payload.mediaSize,
+                        });
+                        if (result) {
+                            payload.mediaPath = result.path;
+                            payload.attachment = result;
+                        }
+                        else {
+                            payload.skippedAttachment = {
+                                reason: 'fetch-failed',
+                                filename: payload.mediaFilename,
+                                size: payload.mediaSize,
+                                sourceUrl: downloadUrl,
+                            };
+                        }
+                    }
+                    catch (err) {
+                        ctx.log.warn(`WhatsApp media download threw: ${err}`);
+                        payload.skippedAttachment = {
+                            reason: 'fetch-failed',
+                            filename: payload.mediaFilename,
+                            size: payload.mediaSize,
+                            sourceUrl: downloadUrl,
+                            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(() => {
                 ctx.broadcast({ type: 'whatsapp_message', payload });
                 notifyTriggerSubscribers(payload);
             });
@@ -272,9 +374,12 @@ function normalizeBaileysMessage(sessionId, eventName, data, ts, baseUrl) {
         ? (pickString(d.groupName) ?? pickString(d.subject) ?? pickString(d.chatName))
         : undefined;
     // Body / media extraction
-    const { body, mediaType, mediaUrl: rawMediaUrl } = extractContent(d, message);
+    const { body, mediaType, mediaUrl: rawMediaUrl, mediaMimetype, mediaSize, mediaFilename } = extractContent(d, message);
     // Resolve relative mediaUrl against baseUrl
     const mediaUrl = rawMediaUrl ? resolveMediaUrl(rawMediaUrl, baseUrl) : undefined;
+    // Stable Baileys message id — needed to ask the upstream for the decrypted bytes.
+    const messageId = pickString(d.id) ??
+        (key ? pickString(key.id) : undefined);
     // Timestamp resolution. Baileys messageTimestamp is in seconds; envelope `ts`
     // might already be ms. Heuristic: anything < 10^12 is treated as seconds.
     const rawTs = pickNumber(d.timestamp) ??
@@ -294,6 +399,10 @@ function normalizeBaileysMessage(sessionId, eventName, data, ts, baseUrl) {
         mediaUrl,
         direction,
         chatId: remoteJid ?? from,
+        messageId,
+        mediaMimetype,
+        mediaSize,
+        mediaFilename,
     };
 }
 function extractContent(envelope, message) {
@@ -302,16 +411,61 @@ function extractContent(envelope, message) {
     const directMediaType = normalizeMediaType(pickString(envelope.mediaType) ?? pickString(envelope.type));
     const directMediaUrl = pickString(envelope.mediaUrl) ??
         pickString(envelope.media?.url);
-    if (directBody !== undefined || directMediaType || directMediaUrl) {
+    // 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.
+    //
+    // 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 flatType = pickString(envelope.type);
+    const flatTypeIsKnownMedia = !!flatType && KNOWN_MEDIA_TYPES.has(flatType);
+    if ((flatHasMedia || flatTypeIsKnownMedia) && !directMediaType && !directMediaUrl) {
+        return {
+            body: directBody,
+            mediaType: classifyFlatType(flatType),
+            mediaUrl: undefined,
+            mediaMimetype: undefined,
+            mediaFilename: undefined,
+            mediaSize: undefined,
+        };
+    }
+    // Short-circuit ONLY when the upstream pre-normalized actual media metadata
+    // at the top level. Earlier this branch also fired on `directBody` alone,
+    // which meant a Baileys envelope carrying `body='caption text'` + a real
+    // `message.imageMessage` proto was returned as text-only — the media
+    // extraction below was skipped and downstream `payload.mediaType` came back
+    // undefined. Fall through when only the body is set so the Baileys proto
+    // gets a chance to provide the media info.
+    if (directMediaType || directMediaUrl) {
+        const mediaObj = envelope.media;
         return {
             body: directBody,
             mediaType: directMediaType,
             mediaUrl: directMediaUrl,
+            mediaMimetype: pickString(envelope.mediaMimetype) ?? pickString(envelope.mimetype) ?? pickString(mediaObj?.mimetype),
+            mediaSize: pickNumber(envelope.mediaSize) ?? pickNumber(envelope.fileLength) ?? pickNumber(mediaObj?.size),
+            mediaFilename: pickString(envelope.mediaFilename) ?? pickString(envelope.fileName) ?? pickString(mediaObj?.fileName),
         };
     }
     // 2. Baileys `message` proto shape.
-    if (!message)
-        return {};
+    if (!message) {
+        // No proto to inspect but we may still have a plain text body at the top
+        // level. Return it so the trigger gets *something*; mediaType remains
+        // unset which is correct.
+        return directBody !== undefined ? { body: directBody } : {};
+    }
     const conversation = pickString(message.conversation);
     if (conversation)
         return { body: conversation };
@@ -324,34 +478,53 @@ function extractContent(envelope, message) {
     const image = message.imageMessage;
     if (image) {
         return {
-            body: pickString(image.caption) ?? '',
+            body: pickString(image.caption) ?? directBody ?? '',
             mediaType: 'image',
             mediaUrl: pickString(image.url),
+            mediaMimetype: pickString(image.mimetype),
+            mediaSize: pickNumber(image.fileLength),
         };
     }
     const video = message.videoMessage;
     if (video) {
         return {
-            body: pickString(video.caption) ?? '',
+            body: pickString(video.caption) ?? directBody ?? '',
             mediaType: 'video',
             mediaUrl: pickString(video.url),
+            mediaMimetype: pickString(video.mimetype),
+            mediaSize: pickNumber(video.fileLength),
         };
     }
     const audio = message.audioMessage;
     if (audio) {
-        return { body: '', mediaType: 'audio', mediaUrl: pickString(audio.url) };
+        return {
+            body: directBody ?? '',
+            mediaType: 'audio',
+            mediaUrl: pickString(audio.url),
+            mediaMimetype: pickString(audio.mimetype),
+            mediaSize: pickNumber(audio.fileLength),
+        };
     }
     const doc = message.documentMessage;
     if (doc) {
         return {
-            body: pickString(doc.fileName) ?? pickString(doc.caption) ?? '',
+            body: pickString(doc.fileName) ?? pickString(doc.caption) ?? directBody ?? '',
             mediaType: 'document',
             mediaUrl: pickString(doc.url),
+            mediaMimetype: pickString(doc.mimetype),
+            mediaSize: pickNumber(doc.fileLength),
+            mediaFilename: pickString(doc.fileName) ?? pickString(doc.title),
         };
     }
     const sticker = message.stickerMessage;
     if (sticker) {
-        return { body: '', mediaType: 'sticker', mediaUrl: pickString(sticker.url) };
+        return {
+            body: directBody ?? '',
+            mediaType: 'sticker',
+            mediaUrl: pickString(sticker.url),
+            mediaMimetype: pickString(sticker.mimetype),
+            mediaSize: pickNumber(sticker.fileLength),
+        };
     }
     // Some Baileys variants nest the actual message under ephemeralMessage / viewOnceMessage.
     const ephemeral = message.ephemeralMessage?.message;
@@ -360,7 +533,9 @@ function extractContent(envelope, message) {
     const viewOnce = message.viewOnceMessage?.message;
     if (viewOnce)
         return extractContent(envelope, viewOnce);
-    return {};
+    // Unknown proto shape (reaction, protocol, etc.) — preserve the top-level
+    // body so the trigger still receives the text.
+    return directBody !== undefined ? { body: directBody } : {};
 }
 function resolveMediaUrl(url, baseUrl) {
     if (/^[a-z][a-z0-9+\-.]*:\/\//i.test(url))
@@ -382,6 +557,53 @@ 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:
+ *   - imageMessage → image
+ *   - videoMessage, videoNoteMessage → video
+ *   - audioMessage, pttMessage → audio
+ *   - documentMessage, documentWithCaptionMessage → document
+ *   - stickerMessage → sticker
+ *   - any other `*Message` or unknown signal → document (catch-all "it's a file")
+ * Returns `'document'` as a safe default rather than `undefined` so the
+ * download predicate (`!!payload.mediaType && !!payload.messageId`) stays
+ * true and the proxy is given a chance to deliver the bytes.
+ */
+function classifyFlatType(type) {
+    const t = (type ?? '').toLowerCase();
+    if (t.startsWith('image'))
+        return 'image';
+    if (t.startsWith('video'))
+        return 'video';
+    if (t.startsWith('audio') || t.startsWith('ptt') || t.startsWith('voice'))
+        return 'audio';
+    if (t.startsWith('sticker'))
+        return 'sticker';
+    // documentMessage, documentWithCaptionMessage, and ANY other `*Message`
+    // variant we don't explicitly know about. Better to attempt the download
+    // and let the proxy decide than to silently skip an unknown media kind.
+    return 'document';
+}
 function pickString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
@@ -573,6 +795,25 @@ export const whatsappTriggerHandler = {
         const groupName = msg.isGroup
             ? (msg.groupName?.trim() || humanizeGroupJid(msg.chatId))
             : '';
+        // 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);
+        }
+        else if (msg.skippedAttachment) {
+            const sk = msg.skippedAttachment;
+            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,
@@ -584,6 +825,17 @@ export const whatsappTriggerHandler = {
             'whatsapp.direction': msg.direction,
             'whatsapp.mediaType': msg.mediaType ?? '',
             'whatsapp.mediaUrl': msg.mediaUrl ?? '',
+            // New: local path + metadata for inbound media, plus a ready-to-paste
+            // attachments block. Additive — old templates ignore these.
+            'whatsapp.attachmentPath': msg.attachment?.path ?? '',
+            'whatsapp.attachmentMime': msg.attachment?.mimetype ?? msg.mediaMimetype ?? '',
+            '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(),
         };
     },
@@ -592,9 +844,24 @@ export const whatsappTriggerHandler = {
         const sender = msg.fromName ? `${msg.fromName} (${msg.from})` : msg.from;
         const channel = msg.isGroup ? `group "${msg.groupName ?? msg.from}"` : 'DM';
         const verb = msg.direction === 'outbound' ? 'sent' : 'received';
-        const media = msg.mediaType
-            ? `\n[${msg.mediaType} attachment${msg.mediaUrl ? ` ${msg.mediaUrl}` : ''}]`
-            : '';
-        return `WhatsApp message ${verb} in ${channel}\nFrom: ${sender}\nSession: ${msg.sessionId}\nTime: ${new Date(msg.timestamp).toISOString()}${media}\n\n${msg.body}`;
+        // If we downloaded the media, surface the local path as the agent-facing
+        // attachment marker (it supersedes the raw mediaUrl). If we tried but
+        // failed, surface that explicitly so the agent doesn't silently miss it.
+        let mediaSuffix = '';
+        if (msg.attachment) {
+            mediaSuffix = `\n\n${formatAttachmentLine(msg.attachment)}`;
+        }
+        else if (msg.skippedAttachment) {
+            const sk = msg.skippedAttachment;
+            const sizeMb = typeof sk.size === 'number' ? `${Math.round(sk.size / (1024 * 1024))}MB` : 'unknown';
+            mediaSuffix = `\n\n[attachment-skipped: ${sk.reason} name=${sk.filename ?? 'unknown'} size=${sizeMb}${sk.detail ? ` detail=${sk.detail}` : ''}]`;
+        }
+        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

@@ -10,8 +10,10 @@ import * as os from 'os';
 import { logger } from '../utils/logger.js';
 import { loadAreas } from '../data/index.js';
 const log = logger.files;
-// Get or create temp directory for tide-commander uploads
-const TEMP_DIR = path.join(os.tmpdir(), 'tide-commander-uploads');
+// Get or create temp directory for tide-commander uploads. Exported so other
+// modules (attachment-downloader, attachment-janitor) put their files under the
+// same root that Express already serves statically at `/uploads/`.
+export const TEMP_DIR = path.join(os.tmpdir(), 'tide-commander-uploads');
 if (!fs.existsSync(TEMP_DIR)) {
     fs.mkdirSync(TEMP_DIR, { recursive: true });
 }
@@ -784,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 {
@@ -2859,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;
@@ -2877,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 });
     }
 });