tide-commander 1.87.0 → 1.89.0

package/dist/src/packages/server/integrations/whatsapp/whatsapp-routes.js

@@ -198,6 +198,74 @@ export function createWhatsAppRoutes(ctx) {
             res.status(502).json({ error: err instanceof Error ? err.message : String(err) });
         }
     });
+    // ─── POST /sessions/:sessionId/chats/:chatId/sync-messages — Force on-demand history sync for a chat ───
+    router.post('/sessions/:sessionId/chats/:chatId/sync-messages', async (req, res) => {
+        const built = getClient();
+        if ('error' in built) {
+            res.status(built.status).json({ error: built.error });
+            return;
+        }
+        const rawCount = typeof req.query.count === 'string' ? Number(req.query.count) : NaN;
+        const count = Number.isFinite(rawCount) && rawCount > 0 ? Math.floor(rawCount) : 50;
+        try {
+            const result = await built.client.syncChatMessages(req.params.sessionId, req.params.chatId, count);
+            res.json({ success: true, data: result });
+        }
+        catch (err) {
+            log.error(`WhatsApp syncChatMessages error: ${err}`);
+            res.status(502).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // ─── POST /sessions/:sessionId/sync-contacts — Force address-book resync via Baileys app-state ───
+    router.post('/sessions/:sessionId/sync-contacts', async (req, res) => {
+        const built = getClient();
+        if ('error' in built) {
+            res.status(built.status).json({ error: built.error });
+            return;
+        }
+        try {
+            const result = await built.client.syncContacts(req.params.sessionId);
+            res.json({ success: true, data: result });
+        }
+        catch (err) {
+            log.error(`WhatsApp syncContacts error: ${err}`);
+            res.status(502).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // ─── GET /sessions/:sessionId/contacts — List contacts for a session ───
+    router.get('/sessions/:sessionId/contacts', async (req, res) => {
+        const built = getClient();
+        if ('error' in built) {
+            res.status(built.status).json({ error: built.error });
+            return;
+        }
+        try {
+            const result = await built.client.getContacts(req.params.sessionId);
+            res.json({ success: true, data: result });
+        }
+        catch (err) {
+            log.error(`WhatsApp getContacts error: ${err}`);
+            res.status(502).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // ─── GET /sessions/:sessionId/chats/:chatId/messages — Fetch recent messages for a chat ───
+    router.get('/sessions/:sessionId/chats/:chatId/messages', async (req, res) => {
+        const built = getClient();
+        if ('error' in built) {
+            res.status(built.status).json({ error: built.error });
+            return;
+        }
+        const rawLimit = typeof req.query.limit === 'string' ? Number(req.query.limit) : NaN;
+        const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.floor(rawLimit) : 50;
+        try {
+            const result = await built.client.getChatMessages(req.params.sessionId, req.params.chatId, limit);
+            res.json({ success: true, data: result });
+        }
+        catch (err) {
+            log.error(`WhatsApp getChatMessages error: ${err}`);
+            res.status(502).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
     // ─── POST /send-message — Send a text message via Baileys ───
     router.post('/send-message', async (req, res) => {
         const body = (req.body ?? {});

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

@@ -13,6 +13,23 @@ import { WhatsAppWsClient } from './whatsapp-ws-client.js';
 import { MessageDedupeCache } from './message-dedupe.js';
 import { ContactNameCache } from './contact-name-cache.js';
 import { WhatsAppClient } from './whatsapp-client.js';
+import { createLogger } from '../../utils/logger.js';
+const log = createLogger('WhatsAppTrigger');
+// Module-level subscriber set fed by the in-process bridge whenever a normalized
+// WhatsApp message is broadcast. The trigger-service-facing handler below
+// registers its callback here, so subscribers stay attached even when the bridge
+// restarts (e.g. on config change).
+const triggerSubscribers = new Set();
+function notifyTriggerSubscribers(payload) {
+    for (const cb of triggerSubscribers) {
+        try {
+            cb(payload);
+        }
+        catch {
+            // Subscriber errors must not break the bridge — swallow.
+        }
+    }
+}
 // Dedupe cache config. The upstream whatsapp-api fires BOTH `message` and
 // `message_create` for the same Baileys event on inbound DMs (see
 // providers/baileysSessionManager.js around the `messages.upsert` handler — it
@@ -105,6 +122,7 @@ export function createWhatsAppTriggerHandler(ctx) {
                 !!payload.from;
             if (!needsEnrichment) {
                 ctx.broadcast({ type: 'whatsapp_message', payload });
+                notifyTriggerSubscribers(payload);
                 return;
             }
             void contactNames.lookup(msg.sessionId, payload.from).then((name) => {
@@ -112,9 +130,11 @@ export function createWhatsAppTriggerHandler(ctx) {
                 if (sanitized)
                     payload.fromName = sanitized;
                 ctx.broadcast({ type: 'whatsapp_message', payload });
+                notifyTriggerSubscribers(payload);
             }, (err) => {
                 ctx.log.warn(`WhatsApp contact lookup failed: ${err}`);
                 ctx.broadcast({ type: 'whatsapp_message', payload });
+                notifyTriggerSubscribers(payload);
             });
         }
         // Other event types (message_ack, group_join, group_leave, hello, error) are
@@ -216,6 +236,7 @@ function normalizeBaileysMessage(sessionId, eventName, data, ts, baseUrl) {
         mediaType,
         mediaUrl,
         direction,
+        chatId: remoteJid ?? from,
     };
 }
 function extractContent(envelope, message) {
@@ -355,3 +376,109 @@ export function sanitizeFromName(name, fromJid) {
     }
     return trimmed;
 }
+// Chat IDs that represent non-message channels (status updates, broadcast
+// lists). The bridge surfaces them as messages because Baileys delivers
+// status posts via `messages.upsert`, but they're not 1:1 / group chats and
+// most triggers shouldn't fire on them.
+function isStatusOrBroadcastChat(chatId) {
+    if (!chatId)
+        return false;
+    if (chatId === 'status@broadcast')
+        return true;
+    if (chatId.endsWith('@broadcast'))
+        return true;
+    return false;
+}
+// Drop presence/typing/group-system events that arrive through the bridge
+// with no body and no media — they fire the agent for nothing. Emoji-only
+// bodies and media-with-empty-caption are real content and pass through.
+export function isEmptyContentMessage(msg) {
+    const bodyEmpty = !msg.body || msg.body.trim().length === 0;
+    const noMedia = !msg.mediaType && !msg.mediaUrl;
+    return bodyEmpty && noMedia;
+}
+let triggerUnsubscribe = null;
+export const whatsappTriggerHandler = {
+    triggerType: 'whatsapp',
+    async startListening(onEvent) {
+        const cb = (msg) => {
+            onEvent({
+                source: 'whatsapp',
+                type: 'message',
+                data: msg,
+                timestamp: msg.timestamp,
+            });
+        };
+        triggerSubscribers.add(cb);
+        triggerUnsubscribe = () => triggerSubscribers.delete(cb);
+    },
+    async stopListening() {
+        if (triggerUnsubscribe) {
+            triggerUnsubscribe();
+            triggerUnsubscribe = null;
+        }
+    },
+    structuralMatch(trigger, event) {
+        const msg = event.data;
+        const cfg = trigger.config;
+        // Drop status updates and broadcast-list messages by default — they're
+        // surfaced through the same bridge as real messages but represent stories /
+        // broadcasts, not conversations. Opt-in via includeStatuses.
+        if (!cfg.includeStatuses && isStatusOrBroadcastChat(msg.chatId))
+            return false;
+        if (isEmptyContentMessage(msg)) {
+            log.debug(`whatsapp.trigger.skipped reason=empty_content session=${msg.sessionId}`);
+            return false;
+        }
+        if (cfg.direction && cfg.direction !== 'any' && msg.direction !== cfg.direction)
+            return false;
+        if (cfg.groupOnly && !msg.isGroup)
+            return false;
+        if (cfg.dmOnly && msg.isGroup)
+            return false;
+        if (cfg.sessionId && msg.sessionId !== cfg.sessionId)
+            return false;
+        if (cfg.fromFilter?.length) {
+            const fromLower = msg.from.toLowerCase();
+            if (!cfg.fromFilter.some(f => fromLower.includes(f.toLowerCase())))
+                return false;
+        }
+        if (cfg.bodyPattern) {
+            try {
+                if (!new RegExp(cfg.bodyPattern, 'i').test(msg.body))
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
+        return true;
+    },
+    extractVariables(trigger, event) {
+        const msg = event.data;
+        void trigger;
+        return {
+            'whatsapp.from': msg.from,
+            'whatsapp.fromName': msg.fromName ?? '',
+            'whatsapp.body': msg.body,
+            'whatsapp.sessionId': msg.sessionId,
+            'whatsapp.chatId': msg.chatId,
+            'whatsapp.isGroup': String(msg.isGroup),
+            'whatsapp.groupName': msg.groupName ?? '',
+            'whatsapp.direction': msg.direction,
+            'whatsapp.mediaType': msg.mediaType ?? '',
+            'whatsapp.mediaUrl': msg.mediaUrl ?? '',
+            'whatsapp.timestamp': new Date(msg.timestamp).toISOString(),
+        };
+    },
+    formatEventForLLM(event) {
+        const msg = event.data;
+        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}`;
+    },
+};

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

@@ -0,0 +1,221 @@
+/**
+ * Database Routes
+ * REST API endpoints for exploring database buildings.
+ *
+ * Mirrors the WebSocket database handler operations (test/list/schema/query)
+ * over plain HTTP so curl-based agent skills can use them.
+ */
+import { Router } from 'express';
+import { databaseService, buildingService } from '../services/index.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('DatabaseRoutes');
+const router = Router();
+const MAX_QUERY_LIMIT = 10000;
+const DEFAULT_QUERY_LIMIT = 1000;
+function getDatabaseBuilding(buildingId) {
+    const building = buildingService.getBuilding(buildingId);
+    if (!building || building.type !== 'database' || !building.database) {
+        return null;
+    }
+    return building;
+}
+function getConnection(buildingId, connectionId) {
+    const building = getDatabaseBuilding(buildingId);
+    if (!building)
+        return null;
+    return building.database.connections.find(c => c.id === connectionId) || null;
+}
+function redactConnection(c) {
+    return {
+        id: c.id,
+        name: c.name,
+        engine: c.engine,
+        host: c.host,
+        port: c.port,
+        username: c.username,
+        database: c.database,
+        filepath: c.filepath,
+        ssl: c.ssl,
+        hasPassword: Boolean(c.password),
+        ssh: c.ssh
+            ? { enabled: c.ssh.enabled, host: c.ssh.host, port: c.ssh.port, username: c.ssh.username }
+            : undefined,
+    };
+}
+// GET /api/database/buildings - list all database buildings (redacted)
+router.get('/buildings', (_req, res) => {
+    const buildings = buildingService.getBuildings()
+        .filter(b => b.type === 'database' && b.database)
+        .map(b => ({
+        id: b.id,
+        name: b.name,
+        activeConnectionId: b.database.activeConnectionId,
+        activeDatabase: b.database.activeDatabase,
+        connections: b.database.connections.map(redactConnection),
+    }));
+    res.json({ buildings });
+});
+// GET /api/database/buildings/:buildingId - one database building (redacted)
+router.get('/buildings/:buildingId', (req, res) => {
+    const building = getDatabaseBuilding(String(req.params.buildingId));
+    if (!building) {
+        res.status(404).json({ error: 'Database building not found' });
+        return;
+    }
+    res.json({
+        id: building.id,
+        name: building.name,
+        activeConnectionId: building.database.activeConnectionId,
+        activeDatabase: building.database.activeDatabase,
+        connections: building.database.connections.map(redactConnection),
+    });
+});
+// POST /api/database/buildings/:buildingId/connections/:connectionId/test
+router.post('/buildings/:buildingId/connections/:connectionId/test', async (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const connectionId = String(req.params.connectionId);
+    const connection = getConnection(buildingId, connectionId);
+    if (!connection) {
+        res.status(404).json({ error: 'Connection not found' });
+        return;
+    }
+    try {
+        const result = await databaseService.testConnection(connection);
+        res.json(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        log.error(`testConnection failed for ${buildingId}/${connectionId}:`, message);
+        res.status(500).json({ success: false, error: message });
+    }
+});
+// GET /api/database/buildings/:buildingId/connections/:connectionId/databases
+router.get('/buildings/:buildingId/connections/:connectionId/databases', async (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const connectionId = String(req.params.connectionId);
+    const connection = getConnection(buildingId, connectionId);
+    if (!connection) {
+        res.status(404).json({ error: 'Connection not found' });
+        return;
+    }
+    try {
+        const databases = await databaseService.listDatabases(connection);
+        res.json({ databases });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        log.error(`listDatabases failed for ${buildingId}/${connectionId}:`, message);
+        res.status(500).json({ error: message });
+    }
+});
+// GET /api/database/buildings/:buildingId/connections/:connectionId/databases/:database/tables
+router.get('/buildings/:buildingId/connections/:connectionId/databases/:database/tables', async (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const connectionId = String(req.params.connectionId);
+    const database = String(req.params.database);
+    const connection = getConnection(buildingId, connectionId);
+    if (!connection) {
+        res.status(404).json({ error: 'Connection not found' });
+        return;
+    }
+    try {
+        const tables = await databaseService.listTables(connection, database);
+        res.json({ database, tables });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        log.error(`listTables failed for ${buildingId}/${connectionId}/${database}:`, message);
+        res.status(500).json({ error: message });
+    }
+});
+// GET /api/database/buildings/:buildingId/connections/:connectionId/databases/:database/tables/:table/columns
+// Lean variant of /schema — returns only the column list (no indexes / foreign keys).
+router.get('/buildings/:buildingId/connections/:connectionId/databases/:database/tables/:table/columns', async (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const connectionId = String(req.params.connectionId);
+    const database = String(req.params.database);
+    const table = String(req.params.table);
+    const connection = getConnection(buildingId, connectionId);
+    if (!connection) {
+        res.status(404).json({ error: 'Connection not found' });
+        return;
+    }
+    try {
+        const { columns } = await databaseService.getTableSchema(connection, database, table);
+        res.json({ database, table, columns });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        log.error(`describe (columns) failed for ${buildingId}/${connectionId}/${database}/${table}:`, message);
+        res.status(500).json({ error: message });
+    }
+});
+// GET /api/database/buildings/:buildingId/connections/:connectionId/databases/:database/tables/:table/schema
+router.get('/buildings/:buildingId/connections/:connectionId/databases/:database/tables/:table/schema', async (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const connectionId = String(req.params.connectionId);
+    const database = String(req.params.database);
+    const table = String(req.params.table);
+    const connection = getConnection(buildingId, connectionId);
+    if (!connection) {
+        res.status(404).json({ error: 'Connection not found' });
+        return;
+    }
+    try {
+        const schema = await databaseService.getTableSchema(connection, database, table);
+        res.json({ database, table, ...schema });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        log.error(`getTableSchema failed for ${buildingId}/${connectionId}/${database}/${table}:`, message);
+        res.status(500).json({ error: message });
+    }
+});
+// POST /api/database/buildings/:buildingId/connections/:connectionId/query
+// Body: { database: string, query: string, limit?: number, recordHistory?: boolean }
+router.post('/buildings/:buildingId/connections/:connectionId/query', async (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const connectionId = String(req.params.connectionId);
+    const { database, query, limit, recordHistory } = req.body ?? {};
+    if (typeof database !== 'string' || !database) {
+        res.status(400).json({ error: 'Body field "database" is required' });
+        return;
+    }
+    if (typeof query !== 'string' || !query.trim()) {
+        res.status(400).json({ error: 'Body field "query" is required' });
+        return;
+    }
+    const connection = getConnection(buildingId, connectionId);
+    if (!connection) {
+        res.status(404).json({ error: 'Connection not found' });
+        return;
+    }
+    const effectiveLimit = Math.min(Math.max(1, Number.isFinite(limit) ? Number(limit) : DEFAULT_QUERY_LIMIT), MAX_QUERY_LIMIT);
+    try {
+        const result = await databaseService.executeQuery(connection, database, query, effectiveLimit);
+        if (recordHistory && result.status === 'success') {
+            databaseService.addToHistory(buildingId, result);
+        }
+        const status = result.status === 'success' ? 200 : 400;
+        res.status(status).json(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        log.error(`executeQuery failed for ${buildingId}/${connectionId}:`, message);
+        res.status(500).json({ status: 'error', error: message });
+    }
+});
+// GET /api/database/buildings/:buildingId/history?limit=100
+router.get('/buildings/:buildingId/history', (req, res) => {
+    const buildingId = String(req.params.buildingId);
+    const building = getDatabaseBuilding(buildingId);
+    if (!building) {
+        res.status(404).json({ error: 'Database building not found' });
+        return;
+    }
+    const rawLimit = Number(req.query.limit);
+    const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 500) : 100;
+    const history = databaseService.getHistory(buildingId, limit);
+    res.json({ history });
+});
+export default router;