tide-commander 1.87.0 → 1.89.0

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

@@ -6,22 +6,217 @@
 import { Router } from 'express';
 import multer from 'multer';
 import * as slackClient from './slack-client.js';
-import { loadConfig } from './slack-config.js';
+import { loadConfig, getConfigValues, setConfigValues, DEFAULT_INSTANCE_ID, instanceSecretKey } from './slack-config.js';
+import { getInstance, removeInstance as unloadInstance, } from './slack-instance.js';
+import { listInstanceMetas, getInstanceMeta, hasInstance, addInstance, renameInstance, removeInstance as removeInstanceMeta, validateInstanceId, } from './slack-instance-manifest.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('SlackRoutes');
 const router = Router();
+/**
+ * Pick the instance id from the request. Order of precedence:
+ *   1. ?instance=<id> query param
+ *   2. body.instanceId (POST/PATCH only)
+ *   3. 'default'
+ * Returns null + writes a 404 if the requested id isn't in the manifest.
+ */
+function resolveInstanceIdOr404(req, res) {
+    const fromQuery = req.query.instance?.trim();
+    const body = (req.body ?? {});
+    const fromBody = typeof body.instanceId === 'string' ? body.instanceId.trim() : undefined;
+    const id = fromQuery || fromBody || DEFAULT_INSTANCE_ID;
+    if (!hasInstance(id)) {
+        res.status(404).json({ error: `Slack instance "${id}" not found` });
+        return null;
+    }
+    return id;
+}
+function svc(req, res) {
+    const id = resolveInstanceIdOr404(req, res);
+    if (!id)
+        return null;
+    return { id, inst: getInstance(id) };
+}
+// ─── /instances CRUD ───
+// GET /api/slack/instances — list all instances + their config + status
+router.get('/instances', (req, res) => {
+    void req;
+    const metas = listInstanceMetas();
+    const result = metas.map((meta) => {
+        const inst = getInstance(meta.id);
+        return {
+            id: meta.id,
+            label: meta.label,
+            createdAt: meta.createdAt,
+            status: inst.getStatus(),
+            config: loadConfig(meta.id),
+        };
+    });
+    res.json({ instances: result });
+});
+// POST /api/slack/instances — create a new instance
+router.post('/instances', (req, res) => {
+    try {
+        const { id, label } = req.body;
+        if (!id) {
+            res.status(400).json({ error: 'id is required' });
+            return;
+        }
+        const validationErr = validateInstanceId(id);
+        if (validationErr) {
+            res.status(400).json({ error: validationErr });
+            return;
+        }
+        const meta = addInstance(id, label || id);
+        // Force-create + wire the SlackInstance so subsequent calls (PATCH /:id,
+        // POST /:id/connect) can call reconnect() immediately.
+        const inst = getInstance(meta.id);
+        ensureInstanceWired(inst);
+        res.json({ instance: meta });
+    }
+    catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+});
+// GET /api/slack/instances/:id — single instance status + config
+router.get('/instances/:id', (req, res) => {
+    const meta = getInstanceMeta(req.params.id);
+    if (!meta) {
+        res.status(404).json({ error: 'Instance not found' });
+        return;
+    }
+    const inst = getInstance(req.params.id);
+    res.json({
+        instance: meta,
+        status: inst.getStatus(),
+        config: loadConfig(req.params.id),
+    });
+});
+// PATCH /api/slack/instances/:id — rename + apply per-instance config / secrets, then reconnect
+router.patch('/instances/:id', async (req, res) => {
+    try {
+        const meta = getInstanceMeta(req.params.id);
+        if (!meta) {
+            res.status(404).json({ error: 'Instance not found' });
+            return;
+        }
+        const body = (req.body ?? {});
+        if (typeof body.label === 'string') {
+            renameInstance(req.params.id, body.label);
+        }
+        if (body.values && typeof body.values === 'object') {
+            // The integration context owns the secret store. We expose it via a
+            // tiny helper exported from index.ts… but to keep this route file
+            // self-contained, we accept that secrets routing happens through
+            // setConfigValues which reads ctx.secrets indirectly via the same
+            // pattern slackPlugin.setConfig uses. Inline secret setter:
+            const secrets = getRequestSecrets(req);
+            if (!secrets) {
+                res.status(500).json({ error: 'Slack integration not initialized' });
+                return;
+            }
+            await setConfigValues(body.values, secrets, req.params.id);
+        }
+        // Reconnect this instance with its new config / secrets.
+        const inst = getInstance(req.params.id);
+        ensureInstanceWired(inst);
+        const updated = loadConfig(req.params.id);
+        const secrets = getRequestSecrets(req);
+        const botToken = secrets?.get(instanceSecretKey('SLACK_BOT_TOKEN', req.params.id));
+        if (updated.enabled && botToken) {
+            try {
+                await inst.reconnect();
+            }
+            catch (e) {
+                log.error(`Slack[${req.params.id}] reconnect failed: ${e instanceof Error ? e.message : e}`);
+            }
+        }
+        else if (!updated.enabled && inst.isConnected()) {
+            await inst.disconnect();
+        }
+        res.json({
+            instance: getInstanceMeta(req.params.id),
+            status: inst.getStatus(),
+            config: loadConfig(req.params.id),
+        });
+    }
+    catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+});
+// DELETE /api/slack/instances/:id — remove instance (manifest + config + connection)
+router.delete('/instances/:id', async (req, res) => {
+    try {
+        if (req.params.id === DEFAULT_INSTANCE_ID) {
+            res.status(400).json({ error: 'Cannot delete the default instance' });
+            return;
+        }
+        if (!getInstanceMeta(req.params.id)) {
+            res.status(404).json({ error: 'Instance not found' });
+            return;
+        }
+        await unloadInstance(req.params.id);
+        removeInstanceMeta(req.params.id);
+        // We deliberately do NOT delete secrets here — the secret store has no
+        // enumerate API and clients can overwrite the per-instance keys via
+        // PATCH if they want them gone. The keys do nothing without a manifest
+        // entry.
+        res.json({ ok: true });
+    }
+    catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+});
+// GET /api/slack/instances/:id/values — config values shaped for the UI form
+router.get('/instances/:id/values', (req, res) => {
+    const meta = getInstanceMeta(req.params.id);
+    if (!meta) {
+        res.status(404).json({ error: 'Instance not found' });
+        return;
+    }
+    const secrets = getRequestSecrets(req);
+    if (!secrets) {
+        res.status(500).json({ error: 'Slack integration not initialized' });
+        return;
+    }
+    res.json({ values: getConfigValues(secrets, req.params.id) });
+});
+let ctxRef = null;
+export function setIntegrationContextForRoutes(ctx) {
+    ctxRef = ctx;
+}
+/** Back-compat alias for older imports — same store, accessed via ctxRef now. */
+export function setSecretStoreForRoutes(store) {
+    ctxRef = store ? { secrets: store } : null;
+}
+function getRequestSecrets(_req) {
+    return ctxRef?.secrets ?? null;
+}
+/**
+ * Ensure a SlackInstance has its integration context wired. Call this any
+ * time we create a new instance at runtime (POST /instances) so reconnect
+ * doesn't throw "not initialized" before the next server boot.
+ */
+function ensureInstanceWired(inst) {
+    if (ctxRef) {
+        // setContext is idempotent; safe to call repeatedly.
+        inst.setContext(ctxRef);
+    }
+}
 // 50 MB cap matches other integrations (docx). Slack's own limit is higher but this keeps memory sane.
 const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
 // POST /api/slack/send — Send a message
 router.post('/send', async (req, res) => {
     try {
+        const handle = svc(req, res);
+        if (!handle)
+            return;
         const { channel, text, threadTs, agentId, workflowInstanceId } = req.body;
         if (!channel || !text) {
             res.status(400).json({ error: 'channel and text are required' });
             return;
         }
-        const result = await slackClient.sendMessage({ channel, text, threadTs, agentId, workflowInstanceId });
-        res.json({ success: true, ts: result.ts, channel: result.channel });
+        const result = await handle.inst.sendMessage({ channel, text, threadTs, agentId, workflowInstanceId });
+        res.json({ success: true, ts: result.ts, channel: result.channel, instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack send error: ${err}`);
@@ -31,18 +226,21 @@ router.post('/send', async (req, res) => {
 // GET /api/slack/messages — Read channel messages
 router.get('/messages', async (req, res) => {
     try {
+        const handle = svc(req, res);
+        if (!handle)
+            return;
         const channel = req.query.channel;
         if (!channel) {
             res.status(400).json({ error: 'channel query param is required' });
             return;
         }
-        const messages = await slackClient.getChannelMessages({
+        const messages = await handle.inst.getChannelMessages({
             channel,
             limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
             oldest: req.query.oldest,
             latest: req.query.latest,
         });
-        res.json({ messages });
+        res.json({ messages, instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack messages error: ${err}`);
@@ -52,18 +250,21 @@ router.get('/messages', async (req, res) => {
 // GET /api/slack/thread — Read thread replies
 router.get('/thread', async (req, res) => {
     try {
+        const handle = svc(req, res);
+        if (!handle)
+            return;
         const channel = req.query.channel;
         const threadTs = req.query.threadTs;
         if (!channel || !threadTs) {
             res.status(400).json({ error: 'channel and threadTs query params are required' });
             return;
         }
-        const messages = await slackClient.getThreadReplies({
+        const messages = await handle.inst.getThreadReplies({
             channel,
             threadTs,
             limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
         });
-        res.json({ messages });
+        res.json({ messages, instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack thread error: ${err}`);
@@ -93,10 +294,13 @@ router.post('/wait-for-reply', async (req, res) => {
     }
 });
 // GET /api/slack/channels — List all channels
-router.get('/channels', async (_req, res) => {
+router.get('/channels', async (req, res) => {
     try {
-        const channels = await slackClient.listChannels();
-        res.json({ channels });
+        const handle = svc(req, res);
+        if (!handle)
+            return;
+        const channels = await handle.inst.listChannels();
+        res.json({ channels, instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack channels error: ${err}`);
@@ -106,13 +310,16 @@ router.get('/channels', async (_req, res) => {
 // POST /api/slack/channels/join — Join a channel
 router.post('/channels/join', async (req, res) => {
     try {
+        const handle = svc(req, res);
+        if (!handle)
+            return;
         const { channel } = req.body;
         if (!channel) {
             res.status(400).json({ error: 'channel is required' });
             return;
         }
-        const result = await slackClient.joinChannel(channel);
-        res.json({ success: true, channel: result });
+        const result = await handle.inst.joinChannel(channel);
+        res.json({ success: true, channel: result, instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack join channel error: ${err}`);
@@ -149,13 +356,16 @@ router.get('/users/:userId', async (req, res) => {
 // POST /api/slack/dm — Send a direct message to a user
 router.post('/dm', async (req, res) => {
     try {
+        const handle = svc(req, res);
+        if (!handle)
+            return;
         const { userId, text, agentId, workflowInstanceId } = req.body;
         if (!userId || !text) {
             res.status(400).json({ error: 'userId and text are required' });
             return;
         }
-        const result = await slackClient.sendDm({ userId, text, agentId, workflowInstanceId });
-        res.json({ success: true, ts: result.ts, channel: result.channel });
+        const result = await handle.inst.sendDm({ userId, text, agentId, workflowInstanceId });
+        res.json({ success: true, ts: result.ts, channel: result.channel, instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack DM error: ${err}`);
@@ -307,16 +517,22 @@ router.post('/reactions/add', async (req, res) => {
         res.status(500).json({ error: `Failed to add reaction: ${err instanceof Error ? err.message : err}` });
     }
 });
-// GET /api/slack/status — Get connection status
-router.get('/status', (_req, res) => {
-    const config = loadConfig();
-    res.json(config);
+// GET /api/slack/status — Get connection status (per-instance via ?instance=)
+router.get('/status', (req, res) => {
+    const handle = svc(req, res);
+    if (!handle)
+        return;
+    const config = loadConfig(handle.id);
+    res.json({ ...config, instanceId: handle.id });
 });
 // POST /api/slack/connect — Manually trigger connection
-router.post('/connect', async (_req, res) => {
+router.post('/connect', async (req, res) => {
     try {
-        await slackClient.reconnect();
-        res.json({ success: true, status: loadConfig() });
+        const handle = svc(req, res);
+        if (!handle)
+            return;
+        await handle.inst.reconnect();
+        res.json({ success: true, status: loadConfig(handle.id), instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack connect error: ${err}`);
@@ -324,10 +540,13 @@ router.post('/connect', async (_req, res) => {
     }
 });
 // POST /api/slack/disconnect — Manually disconnect
-router.post('/disconnect', async (_req, res) => {
+router.post('/disconnect', async (req, res) => {
     try {
-        await slackClient.disconnect();
-        res.json({ success: true, status: loadConfig() });
+        const handle = svc(req, res);
+        if (!handle)
+            return;
+        await handle.inst.disconnect();
+        res.json({ success: true, status: loadConfig(handle.id), instanceId: handle.id });
     }
     catch (err) {
         log.error(`Slack disconnect error: ${err}`);

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

@@ -1,10 +1,16 @@
 /**
  * Slack Trigger Handler
  * Implements TriggerHandler for 'slack' type triggers.
- * Delegates event listening to slack-client's Socket Mode connection.
+ *
+ * Multi-instance: subscribes to onMessage on EVERY known Slack instance and
+ * propagates the source instanceId through the ExternalEvent payload so
+ * triggers can scope themselves to a specific Slack connection (or accept
+ * any).
  */
 import * as slackClient from './slack-client.js';
-let unsubscribe = null;
+import { listInstances } from './slack-instance.js';
+import { listInstanceMetas } from './slack-instance-manifest.js';
+const unsubscribers = [];
 /** Env toggle: set SLACK_REACT_ON_TRIGGER=false (or 0/no/off) to disable the auto-:eyes: ack. */
 function reactOnTriggerEnabled() {
     const raw = (process.env.SLACK_REACT_ON_TRIGGER ?? '').toLowerCase().trim();
@@ -16,34 +22,57 @@ export const slackTriggerHandler = {
     triggerType: 'slack',
     async startListening(onEvent) {
         const autoReact = reactOnTriggerEnabled();
-        unsubscribe = slackClient.onMessage((message) => {
-            // Fire-and-forget :eyes: reaction to ack that the bot saw it. Failure MUST NOT block triggers.
-            if (autoReact) {
-                slackClient
-                    .addReaction({ channel: message.channel, ts: message.ts, name: 'eyes' })
-                    .catch(() => { });
-            }
-            onEvent({
-                source: 'slack',
-                type: 'message',
-                data: message,
-                timestamp: Date.now(),
+        // Subscribe to every instance the manifest knows about. Unknown instances
+        // (created later via the UI) are auto-created with `getInstance()` when
+        // reconnect runs, but we re-subscribe on each integration shutdown/init
+        // cycle so adding a brand-new instance via /instances triggers re-init.
+        const ids = listInstanceMetas().map((m) => m.id);
+        const idSet = new Set(ids);
+        const allInstances = listInstances().filter((i) => idSet.has(i.id));
+        for (const inst of allInstances) {
+            const off = inst.onMessage((message) => {
+                if (autoReact) {
+                    // Use the instance-specific reaction so it posts as the right account.
+                    inst.addReaction({ channel: message.channel, ts: message.ts, name: 'eyes' })
+                        .catch(() => { });
+                }
+                const eventData = { ...message, instanceId: inst.id };
+                onEvent({
+                    source: 'slack',
+                    type: 'message',
+                    data: eventData,
+                    timestamp: Date.now(),
+                });
             });
-        });
+            unsubscribers.push(off);
+        }
     },
     async stopListening() {
-        if (unsubscribe) {
-            unsubscribe();
-            unsubscribe = null;
+        for (const off of unsubscribers) {
+            try {
+                off();
+            }
+            catch { /* ignore */ }
         }
+        unsubscribers.length = 0;
     },
     structuralMatch(trigger, event) {
         const msg = event.data;
         const config = trigger.config;
+        if (config.instanceId && msg.instanceId !== config.instanceId)
+            return false;
         if (config.channelId && msg.channel !== config.channelId)
             return false;
+        if (config.dmOnly && !msg.channel.startsWith('D'))
+            return false;
+        if (config.excludeDms && msg.channel.startsWith('D'))
+            return false;
+        if (msg.isOwnMessage && !config.includeOwnMessages)
+            return false;
         if (config.userFilter?.length && !config.userFilter.includes(msg.userId))
             return false;
+        if (config.excludeUserIds?.length && config.excludeUserIds.includes(msg.userId))
+            return false;
         if (config.messagePattern) {
             try {
                 if (!new RegExp(config.messagePattern).test(msg.text))
@@ -59,7 +88,7 @@ export const slackTriggerHandler = {
     },
     extractVariables(trigger, event) {
         const msg = event.data;
-        void trigger; // trigger config not needed for basic extraction
+        void trigger;
         const files = msg.files ?? [];
         return {
             'slack.user': msg.userName,
@@ -70,6 +99,7 @@ export const slackTriggerHandler = {
             'slack.fileCount': String(files.length),
             'slack.fileIds': files.map((f) => f.id).join(','),
             'slack.fileNames': files.map((f) => f.name ?? '').filter(Boolean).join(','),
+            'slack.instanceId': msg.instanceId,
         };
     },
     formatEventForLLM(event) {
@@ -78,6 +108,9 @@ export const slackTriggerHandler = {
         const filesLine = files.length
             ? `\nAttachments (${files.length}): ${files.map((f) => `${f.name ?? f.id} [${f.mimetype ?? 'unknown'}]`).join(', ')}`
             : '';
-        return `Slack message from @${msg.userName} (${msg.userId}) in #${msg.channel}:\n"${msg.text}"${filesLine}`;
+        const instanceLine = msg.instanceId !== 'default' ? ` [Slack instance: ${msg.instanceId}]` : '';
+        return `Slack message from @${msg.userName} (${msg.userId}) in #${msg.channel}${instanceLine}:\n"${msg.text}"${filesLine}`;
     },
 };
+// `slackClient` import kept (re-exports SlackMessage type used above).
+void slackClient;

package/dist/src/packages/server/integrations/slack/slack-watermark-store.js

@@ -0,0 +1,124 @@
+/**
+ * SlackWatermarkStore
+ *
+ * Per-channel high-water mark of the latest Slack `ts` we've already
+ * dispatched, persisted to ~/.local/share/tide-commander/slack-watermarks.json.
+ *
+ * Used by the polling-mode inbound client (xoxp- user tokens) so that:
+ *   - Each `conversations.history` call uses `oldest=lastTs` and only sees
+ *     messages newer than what we've already processed.
+ *   - Across server restarts we resume where we left off (no replay storm,
+ *     no missed messages within the channel-history retention window).
+ *
+ * Writes are atomic: write to `*.tmp` then `rename` (POSIX atomic on the
+ * same filesystem). A corrupt or missing file is treated as "no watermarks"
+ * and the polling client applies its first-run backfill cap instead.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+const FILE_VERSION = 1;
+/**
+ * Async, file-backed store. Holds the full state in memory after the first
+ * `load()` and writes the whole file atomically on each `set()`. The state
+ * is small (one entry per channel), so full-file rewrites are simpler and
+ * safer than incremental updates.
+ */
+export class SlackWatermarkStore {
+    filePath;
+    now;
+    state = { version: FILE_VERSION, channels: {} };
+    loaded = false;
+    writeChain = Promise.resolve();
+    constructor(opts) {
+        this.filePath = opts.filePath;
+        this.now = opts.now ?? Date.now;
+    }
+    /**
+     * Load state from disk. Missing or unparseable files are treated as
+     * "no state" — we start fresh and the polling client falls back to the
+     * first-run backfill cap.
+     */
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const raw = await fs.readFile(this.filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed && parsed.version === FILE_VERSION && parsed.channels && typeof parsed.channels === 'object') {
+                this.state = {
+                    version: FILE_VERSION,
+                    channels: { ...parsed.channels },
+                };
+            }
+        }
+        catch {
+            // Missing or corrupt → keep the empty default.
+        }
+        this.loaded = true;
+    }
+    /** Return the watermark for a channel, or undefined if we've never seen it. */
+    get(channelId) {
+        return this.state.channels[channelId];
+    }
+    /** True iff we've persisted a watermark for this channel before. */
+    has(channelId) {
+        return Object.prototype.hasOwnProperty.call(this.state.channels, channelId);
+    }
+    /**
+     * Set a channel's watermark to `ts` only if it's strictly newer than what
+     * we already have. Slack ts is a numeric string ("seconds.microseconds"),
+     * lexicographic compare on equal-length strings is correct, but a numeric
+     * compare via parseFloat is safer across length differences.
+     *
+     * Returns true if we updated state and queued a disk write, false if the
+     * incoming ts was older or equal.
+     */
+    async set(channelId, ts) {
+        if (!ts)
+            return false;
+        const current = this.state.channels[channelId];
+        if (current && parseFloat(ts) <= parseFloat(current.lastTs)) {
+            return false;
+        }
+        this.state.channels[channelId] = {
+            lastTs: ts,
+            lastSeenAt: this.now(),
+        };
+        await this.flush();
+        return true;
+    }
+    /** Forget a channel — used when the user leaves it or it's archived. */
+    async forget(channelId) {
+        if (!this.has(channelId))
+            return;
+        delete this.state.channels[channelId];
+        await this.flush();
+    }
+    /** All channel ids currently tracked. */
+    channels() {
+        return Object.keys(this.state.channels);
+    }
+    /**
+     * Atomic write: serialize state, write to `<file>.tmp`, then rename. The
+     * rename is atomic on POSIX so a crash mid-write can never leave a
+     * truncated JSON file at the canonical path.
+     *
+     * Concurrent calls are serialized via a promise chain so two parallel
+     * `set()` calls can't interleave their writes.
+     */
+    flush() {
+        const next = this.writeChain.then(() => this.writeFile());
+        // Don't propagate write errors into the chain itself — if one write fails,
+        // the next one should still be attempted.
+        this.writeChain = next.catch(() => undefined);
+        return next;
+    }
+    async writeFile() {
+        const dir = path.dirname(this.filePath);
+        await fs.mkdir(dir, { recursive: true });
+        const tmp = `${this.filePath}.tmp`;
+        const body = JSON.stringify(this.state, null, 2);
+        await fs.writeFile(tmp, body, 'utf-8');
+        await fs.rename(tmp, this.filePath);
+    }
+}

package/dist/src/packages/server/integrations/whatsapp/index.js

@@ -10,7 +10,7 @@
  */
 import { createWhatsAppRoutes } from './whatsapp-routes.js';
 import { whatsappConfigSchema, getConfigValues, setConfigValues, loadConfig, WHATSAPP_API_KEY_SECRET, } from './whatsapp-config.js';
-import { createWhatsAppTriggerHandler, } from './whatsapp-trigger-handler.js';
+import { createWhatsAppTriggerHandler, whatsappTriggerHandler, } from './whatsapp-trigger-handler.js';
 import { whatsappSkill } from './whatsapp-skill.js';
 let integrationCtx = null;
 let lastChecked = 0;
@@ -99,9 +99,10 @@ export const whatsappPlugin = {
         return [whatsappSkill];
     },
     getTriggerHandler() {
-        // The TriggerHandler interface here is the trigger-service one.
-        // Our incoming-message bridge is in-process and not surfaced through it.
-        return null;
+        // Real trigger-service handler. Subscribes to the in-process bridge's
+        // notifyTriggerSubscribers stream so events flow into trigger evaluation
+        // even across bridge restarts.
+        return whatsappTriggerHandler;
     },
     getStatus() {
         const config = loadConfig();

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

@@ -39,6 +39,16 @@ export class WhatsAppClient {
         const data = await this.request('GET', `/api/sessions/${encodeURIComponent(sessionId)}/contacts`);
         return Array.isArray(data) ? data : [];
     }
+    async syncChatMessages(sessionId, chatId, count = 50) {
+        return this.request('POST', `/api/sessions/${encodeURIComponent(sessionId)}/chats/${encodeURIComponent(chatId)}/sync-messages?count=${encodeURIComponent(String(count))}`, {});
+    }
+    async syncContacts(sessionId) {
+        return this.request('POST', `/api/sessions/${encodeURIComponent(sessionId)}/sync-contacts`, {});
+    }
+    async getChatMessages(sessionId, chatId, limit = 50) {
+        const data = await this.request('GET', `/api/sessions/${encodeURIComponent(sessionId)}/chats/${encodeURIComponent(chatId)}/messages?limit=${encodeURIComponent(String(limit))}`);
+        return Array.isArray(data) ? data : [];
+    }
     async sendMediaUrl(sessionId, to, mediaUrl, caption, options) {
         // Upstream body shape: { to, url, caption?, filename? } (type is auto-detected
         // from the fetched URL's Content-Type header). `type` is forwarded for