@rubytech/taskmaster 1.16.3 → 1.17.0

package/dist/gateway/public-chat-api.js

@@ -4,9 +4,9 @@
  * Base path: /public/api/v1/:accountId/
  *
  * Endpoints:
- *   POST /session        — create an anonymous session (returns sessionKey)
+ *   POST /session        — create an anonymous session (returns session_key and session_token)
  *   POST /otp/request    — request an OTP code (phone via WhatsApp/SMS, or email via Brevo)
- *   POST /otp/verify     — verify OTP and get a verified session (returns sessionKey)
+ *   POST /otp/verify     — verify OTP and get a verified session (returns session_key and session_token)
  *   POST /chat           — send a message, receive the agent reply (sync or SSE stream)
  *   GET  /chat/history   — retrieve past messages for a session
  *   POST /chat/abort     — cancel an in-progress agent run
@@ -14,9 +14,9 @@
  *
  * Authentication mirrors the public chat widget: anonymous sessions use a
  * client-provided identity string; verified sessions use OTP sent via phone
- * (WhatsApp with SMS fallback) or email (Brevo). The sessionKey returned
- * from /session or /otp/verify is passed via the X-Session-Key header on
- * subsequent requests.
+ * (WhatsApp with SMS fallback) or email (Brevo). The session_key and
+ * session_token returned from /session or /otp/verify are passed via
+ * X-Session-Key and X-Session-Token headers on subsequent requests.
  *
  * The chat endpoint uses `dispatchInboundMessage` — the same full pipeline
  * as the WebSocket `chat.send` handler — so filler messages, internal hooks,
@@ -26,6 +26,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { resolveAgentWorkspaceDir, resolveSessionAgentId } from "../agents/agent-scope.js";
+import { loadOrCreateSessionSecret, signSessionKey, verifySessionToken, } from "./public-chat/session-token.js";
 import { resolveEffectiveMessagesConfig, resolveIdentityName } from "../agents/identity.js";
 import { dispatchInboundMessage } from "../auto-reply/dispatch.js";
 import { resolveAgentBoundAccountId } from "../routing/bindings.js";
@@ -50,7 +51,7 @@ const API_PREFIX = "/public/api/v1/";
 function setCorsHeaders(res) {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Session-Key");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Session-Key, X-Session-Token");
     res.setHeader("Access-Control-Max-Age", "86400");
 }
 function sendNotFound(res) {
@@ -86,6 +87,29 @@ function getSessionKeyHeader(req) {
         return raw[0]?.trim();
     return undefined;
 }
+function getSessionTokenHeader(req) {
+    const raw = req.headers["x-session-token"];
+    if (typeof raw === "string")
+        return raw.trim();
+    if (Array.isArray(raw))
+        return raw[0]?.trim();
+    return undefined;
+}
+/**
+ * Validate both the session key format and its HMAC token.
+ * Returns the session key string on success, null on any failure.
+ */
+function validateSession(req) {
+    const sessionKey = validateSessionKey(getSessionKeyHeader(req));
+    if (!sessionKey)
+        return null;
+    const token = getSessionTokenHeader(req);
+    if (!token)
+        return null;
+    if (!verifySessionToken(loadOrCreateSessionSecret(), sessionKey, token))
+        return null;
+    return sessionKey;
+}
 /** Minimal phone format check: starts with +, digits only, 7–15 digits. */
 function isValidPhone(phone) {
     return /^\+\d{7,15}$/.test(phone);
@@ -213,7 +237,8 @@ async function handleSession(req, res, accountId, cfg, maxBodyBytes) {
     const agentId = resolvePublicAgentId(cfg, accountId);
     const identifier = `anon-${sessionId}`;
     const sessionKey = buildPublicSessionKey(agentId, identifier);
-    sendJson(res, 200, { session_key: sessionKey, agent_id: agentId });
+    const sessionToken = signSessionKey(loadOrCreateSessionSecret(), sessionKey);
+    sendJson(res, 200, { session_key: sessionKey, session_token: sessionToken, agent_id: agentId });
 }
 // ---------------------------------------------------------------------------
 // Route: POST /otp/request
@@ -351,8 +376,10 @@ async function handleOtpVerify(req, res, accountId, cfg, maxBodyBytes) {
     }
     const agentId = resolvePublicAgentId(cfg, accountId);
     const sessionKey = buildPublicSessionKey(agentId, identifier);
+    const sessionToken = signSessionKey(loadOrCreateSessionSecret(), sessionKey);
     sendJson(res, 200, {
         session_key: sessionKey,
+        session_token: sessionToken,
         agent_id: agentId,
         identifier,
         // Backward-compat: include named field matching the identifier type.
@@ -368,9 +395,9 @@ async function handleChat(req, res, _accountId, cfg, maxBodyBytes) {
         sendMethodNotAllowed(res);
         return;
     }
-    const sessionKey = validateSessionKey(getSessionKeyHeader(req));
+    const sessionKey = validateSession(req);
     if (!sessionKey) {
-        sendInvalidRequest(res, "X-Session-Key header required (obtain from /session or /otp/verify)");
+        sendInvalidRequest(res, "X-Session-Key and X-Session-Token headers required (obtain from /session or /otp/verify)");
         return;
     }
     const body = await readJsonBodyOrError(req, res, maxBodyBytes);
@@ -693,9 +720,9 @@ async function handleChatHistory(req, res) {
         sendMethodNotAllowed(res, "GET");
         return;
     }
-    const sessionKey = validateSessionKey(getSessionKeyHeader(req));
+    const sessionKey = validateSession(req);
     if (!sessionKey) {
-        sendInvalidRequest(res, "X-Session-Key header required");
+        sendInvalidRequest(res, "X-Session-Key and X-Session-Token headers required");
         return;
     }
     const { cfg, storePath, entry } = loadSessionEntry(sessionKey);
@@ -736,9 +763,9 @@ async function handleChatAbort(req, res, maxBodyBytes) {
         sendMethodNotAllowed(res);
         return;
     }
-    const sessionKey = validateSessionKey(getSessionKeyHeader(req));
+    const sessionKey = validateSession(req);
     if (!sessionKey) {
-        sendInvalidRequest(res, "X-Session-Key header required");
+        sendInvalidRequest(res, "X-Session-Key and X-Session-Token headers required");
         return;
     }
     const body = await readJsonBodyOrError(req, res, maxBodyBytes);

package/dist/gateway/server-methods/logs.js

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { getResolvedLoggerSettings } from "../../logging.js";
+import { levelToMinLevel, ALLOWED_LOG_LEVELS } from "../../logging/levels.js";
+import { parseLogLine } from "../../logging/parse-log-line.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateLogsTailParams, } from "../protocol/index.js";
 const DEFAULT_LIMIT = 500;
 const DEFAULT_MAX_BYTES = 250_000;
@@ -134,7 +136,21 @@ export const logsHandlers = {
                 limit: p.limit ?? DEFAULT_LIMIT,
                 maxBytes: p.maxBytes ?? DEFAULT_MAX_BYTES,
             });
-            respond(true, { file, ...result }, undefined);
+            const minLevelNum = p.minLevel !== undefined ? levelToMinLevel(p.minLevel) : undefined;
+            const filteredLines = minLevelNum !== undefined
+                ? result.lines.filter((line) => {
+                    const parsed = parseLogLine(line);
+                    if (!parsed || parsed.level === undefined)
+                        return true; // keep unparseable
+                    const levelNum = ALLOWED_LOG_LEVELS.includes(parsed.level)
+                        ? levelToMinLevel(parsed.level)
+                        : undefined;
+                    if (levelNum === undefined)
+                        return true; // unknown level — keep
+                    return levelNum <= minLevelNum;
+                })
+                : result.lines;
+            respond(true, { file, ...result, lines: filteredLines }, undefined);
         }
         catch (err) {
             respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, `log read failed: ${String(err)}`));

package/dist/gateway/server-methods/public-chat.js

@@ -8,6 +8,7 @@ import { ErrorCodes, errorShape } from "../protocol/index.js";
 import { requestOtp, verifyOtp } from "../public-chat/otp.js";
 import { deliverOtp, hasPhoneMethod, normalizeVerifyMethods } from "../public-chat/deliver-otp.js";
 import { buildPublicSessionKey, resolvePublicAgentId } from "../public-chat/session.js";
+import { loadOrCreateSessionSecret, signSessionKey } from "../public-chat/session-token.js";
 /** Strip spaces, dashes, and parentheses from a phone number. */
 function normalizePhone(raw) {
     return raw.replace(/[\s\-()]/g, "");
@@ -155,9 +156,11 @@ export const publicChatHandlers = {
         }
         const agentId = resolvePublicAgentId(cfg, accountId);
         const sessionKey = buildPublicSessionKey(agentId, identifier);
+        const sessionToken = signSessionKey(loadOrCreateSessionSecret(), sessionKey); // secret is memoised after first load
         respond(true, {
             ok: true,
             sessionKey,
+            sessionToken,
             agentId,
             identifier,
             // Backward compat: include named field matching the identifier type.
@@ -188,9 +191,11 @@ export const publicChatHandlers = {
         const agentId = resolvePublicAgentId(cfg, accountId);
         const identifier = `anon-${cookieId}`;
         const sessionKey = buildPublicSessionKey(agentId, identifier);
+        const sessionToken = signSessionKey(loadOrCreateSessionSecret(), sessionKey); // secret is memoised after first load
         respond(true, {
             ok: true,
             sessionKey,
+            sessionToken,
             agentId,
         });
     },

package/dist/gateway/server-methods/sessions-transcript.js

@@ -30,6 +30,18 @@ function extractTextFromContentBlocks(blocks) {
     }
     return parts.join("\n");
 }
+/** Detect soft-failure tool results: content is JSON with success === false. */
+function isToolResultSoftError(content) {
+    if (!content.trim().startsWith("{"))
+        return false;
+    try {
+        const parsed = JSON.parse(content);
+        return parsed.success === false;
+    }
+    catch {
+        return false;
+    }
+}
 /** Format tool input as readable key=value pairs instead of raw JSON. */
 function formatToolInput(input) {
     if (input == null)
@@ -76,11 +88,12 @@ function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs)
         return entries;
     }
     if (line.type === "tool_result") {
-        const content = line.result != null
+        const rawContent = line.result != null
             ? typeof line.result === "string"
                 ? line.result
                 : JSON.stringify(line.result)
             : "";
+        const content = isToolResultSoftError(rawContent) ? `[error] ${rawContent}` : rawContent;
         entries.push({
             sessionId,
             sessionKey,
@@ -102,7 +115,10 @@ function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs)
         if (msg.role === "toolResult") {
             const textParts = [];
             for (const block of contentBlocks) {
-                if (block && typeof block === "object" && typeof block.text === "string" && block.text.trim()) {
+                if (block &&
+                    typeof block === "object" &&
+                    typeof block.text === "string" &&
+                    block.text.trim()) {
                     textParts.push(block.text.trim());
                 }
             }
@@ -112,13 +128,14 @@ function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs)
             const content = textParts.length > 0 ? textParts.join("\n") : "(empty result)";
             const toolName = typeof msg.toolName === "string" ? msg.toolName : undefined;
             const toolCallId = typeof msg.toolCallId === "string" ? msg.toolCallId : undefined;
+            const isError = msg.isError || isToolResultSoftError(content);
             entries.push({
                 sessionId,
                 sessionKey,
                 agentId,
                 timestamp: ts,
                 type: "tool_result",
-                content: msg.isError ? `[error] ${content}` : content,
+                content: isError ? `[error] ${content}` : content,
                 ...(toolName ? { toolName } : {}),
                 ...(toolCallId ? { toolCallId } : {}),
                 ...(model ? { model } : {}),
@@ -259,6 +276,7 @@ export const sessionsTranscriptHandlers = {
         }
         const p = params;
         const limit = p.limit ?? DEFAULT_LIMIT;
+        const errorsOnly = p.errorsOnly === true;
         const inputCursors = p.cursors ?? {};
         const agentFilter = p.agents && p.agents.length > 0 ? new Set(p.agents) : null;
         try {
@@ -343,13 +361,19 @@ export const sessionsTranscriptHandlers = {
                     }
                 }
             }
-            // Sort by timestamp descending and truncate to limit
-            allEntries.sort((a, b) => {
+            // Filter to errors only if requested: session-level errors OR tool results that failed
+            const filtered = errorsOnly
+                ? allEntries.filter((e) => e.type === "error" ||
+                    (e.type === "tool_result" &&
+                        typeof e.content === "string" &&
+                        e.content.startsWith("[error]")))
+                : allEntries;
+            filtered.sort((a, b) => {
                 const ta = new Date(a.timestamp).getTime();
                 const tb = new Date(b.timestamp).getTime();
                 return tb - ta;
             });
-            const entries = allEntries.slice(0, limit);
+            const entries = filtered.slice(0, limit);
             // Include configured agents so UI filter chips appear even when an
             // agent has no sessions yet. When an agent filter is active (account
             // scoping), only add config agents that match the filter — otherwise

package/dist/gateway/server-methods/whatsapp-conversations.js

@@ -0,0 +1,387 @@
+import { loadConfig, writeConfigFile } from "../../config/config.js";
+import { resolveChannelGroupActivation } from "../../config/group-policy.js";
+import { updateSessionStore } from "../../config/sessions.js";
+import { listRecords } from "../../records/records-manager.js";
+import { normalizeAccountId } from "../../routing/session-key.js";
+import { parseAgentSessionKey } from "../../sessions/session-key-utils.js";
+import { requireActiveWebListener } from "../../web/active-listener.js";
+import { stripEnvelope } from "../chat-sanitize.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateWhatsAppConversationsParams, validateWhatsAppGroupInfoParams, validateWhatsAppMessagesParams, validateWhatsAppSendMessageParams, validateWhatsAppSetActivationParams, } from "../protocol/index.js";
+import { loadCombinedSessionStoreForGateway, parseGroupKey } from "../session-utils.js";
+import { readSessionMessages } from "../session-utils.fs.js";
+// ---------------------------------------------------------------------------
+// Helpers for building conversation + message lists from persistent state
+// ---------------------------------------------------------------------------
+/**
+ * Extract a WhatsApp JID from a DM session key rest segment.
+ * Handles both `whatsapp:dm:{peer}` and `dm:{peer}` formats.
+ * Returns `null` if the key doesn't match a WhatsApp DM pattern.
+ */
+function extractDmJid(rest, entryChannel, entryLastChannel) {
+    const channelDmMatch = rest.match(/^whatsapp:dm:(.+)$/);
+    if (channelDmMatch) {
+        const peer = channelDmMatch[1];
+        return peer.includes("@") ? peer : `${peer.replace(/^\+/, "")}@s.whatsapp.net`;
+    }
+    const plainDmMatch = rest.match(/^dm:(.+)$/);
+    if (plainDmMatch) {
+        const isWhatsApp = entryChannel === "whatsapp" || entryLastChannel === "whatsapp";
+        if (!isWhatsApp)
+            return null;
+        const peer = plainDmMatch[1];
+        return peer.includes("@") ? peer : `${peer.replace(/^\+/, "")}@s.whatsapp.net`;
+    }
+    return null;
+}
+function extractTextFromTranscriptMessage(msg) {
+    if (typeof msg.content === "string")
+        return msg.content.trim() || null;
+    if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+            if (part && typeof part.text === "string" && part.text.trim()) {
+                return part.text.trim();
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract sender info from the `[from: Name (phone)]` tag in group user messages.
+ */
+const FROM_TAG_RE = /\n?\[from:\s*(.+?)\]\s*$/;
+function extractSenderFromBody(body) {
+    const match = body.match(FROM_TAG_RE);
+    if (!match)
+        return { cleanBody: body, sender: "" };
+    const cleanBody = body.slice(0, match.index).trimEnd();
+    const senderRaw = match[1];
+    // Format: "Name (+447857934268)" or just "+447857934268"
+    const namePhoneMatch = senderRaw.match(/^(.+?)\s*\(([^)]+)\)$/);
+    if (namePhoneMatch) {
+        return {
+            cleanBody,
+            sender: namePhoneMatch[2],
+            senderName: namePhoneMatch[1],
+        };
+    }
+    return { cleanBody, sender: senderRaw };
+}
+/**
+ * Build a digits-to-contact-name lookup from the contact records store.
+ */
+function buildContactNameLookup() {
+    const lookup = new Map();
+    try {
+        const records = listRecords();
+        for (const record of records) {
+            if (!record.name)
+                continue;
+            const phone = record.phone ?? record.id;
+            const digits = phone.replace(/\D/g, "");
+            if (digits)
+                lookup.set(digits, record.name);
+        }
+    }
+    catch {
+        // Records file missing or unreadable — no enrichment
+    }
+    return lookup;
+}
+/**
+ * Find the session entry matching a WhatsApp JID in the session store.
+ */
+function findSessionForJid(store, jid, accountId) {
+    for (const [key, entry] of Object.entries(store)) {
+        if (!entry.sessionId)
+            continue;
+        if (accountId !== "default" &&
+            entry.lastAccountId &&
+            normalizeAccountId(entry.lastAccountId) !== accountId) {
+            continue;
+        }
+        const parsed = parseGroupKey(key);
+        if (parsed?.channel === "whatsapp" && parsed.id === jid) {
+            return { key, entry };
+        }
+        const agentParsed = parseAgentSessionKey(key);
+        if (agentParsed) {
+            const dmJid = extractDmJid(agentParsed.rest, entry.channel, entry.lastChannel);
+            if (dmJid === jid)
+                return { key, entry };
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+export const whatsappConversationsHandlers = {
+    "whatsapp.conversations": async ({ respond, params }) => {
+        if (!validateWhatsAppConversationsParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid whatsapp.conversations params: ${formatValidationErrors(validateWhatsAppConversationsParams.errors)}`));
+            return;
+        }
+        const accountId = normalizeAccountId(params.accountId);
+        try {
+            const cfg = loadConfig();
+            // 1. Build conversations from persistent session store
+            const { store } = loadCombinedSessionStoreForGateway(cfg);
+            const conversationMap = new Map();
+            for (const [key, entry] of Object.entries(store)) {
+                // Account filter
+                if (accountId !== "default" &&
+                    entry.lastAccountId &&
+                    normalizeAccountId(entry.lastAccountId) !== accountId) {
+                    continue;
+                }
+                // Groups: key contains :whatsapp:group:{jid}
+                const parsed = parseGroupKey(key);
+                if (parsed?.channel === "whatsapp" &&
+                    (parsed.kind === "group" || parsed.kind === "channel") &&
+                    parsed.id) {
+                    conversationMap.set(parsed.id, {
+                        jid: parsed.id,
+                        type: "group",
+                        name: entry.subject ?? entry.displayName ?? parsed.id,
+                        lastMessageTimestamp: entry.updatedAt ? Math.floor(entry.updatedAt / 1000) : undefined,
+                    });
+                    continue;
+                }
+                // DMs: extract JID from key + entry channel metadata
+                const agentParsed = parseAgentSessionKey(key);
+                if (!agentParsed)
+                    continue;
+                const dmJid = extractDmJid(agentParsed.rest, entry.channel, entry.lastChannel);
+                if (dmJid && !conversationMap.has(dmJid)) {
+                    // Derive display name from entry or peer identifier
+                    const peer = agentParsed.rest.replace(/^(?:whatsapp:)?dm:/, "");
+                    conversationMap.set(dmJid, {
+                        jid: dmJid,
+                        type: "dm",
+                        name: entry.displayName ?? peer,
+                        lastMessageTimestamp: entry.updatedAt ? Math.floor(entry.updatedAt / 1000) : undefined,
+                    });
+                }
+            }
+            // 2. Merge with live Baileys data (optional enrichment — may not be connected)
+            try {
+                const { listener } = requireActiveWebListener(accountId);
+                if (listener.listConversations) {
+                    const live = await listener.listConversations();
+                    for (const c of live) {
+                        const existing = conversationMap.get(c.jid);
+                        if (existing) {
+                            // Prefer live name when available and meaningful
+                            if (c.name && c.name !== c.jid)
+                                existing.name = c.name;
+                            if (c.lastMessageTimestamp &&
+                                (!existing.lastMessageTimestamp ||
+                                    c.lastMessageTimestamp > existing.lastMessageTimestamp)) {
+                                existing.lastMessageTimestamp = c.lastMessageTimestamp;
+                            }
+                        }
+                        else {
+                            conversationMap.set(c.jid, c);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Baileys not connected — session store data is sufficient
+            }
+            // 3. Enrich DM names from contact records
+            const contactNames = buildContactNameLookup();
+            for (const conv of conversationMap.values()) {
+                if (conv.type !== "dm")
+                    continue;
+                // JID format: digits@s.whatsapp.net
+                const digits = conv.jid.replace(/@.*$/, "");
+                const contactName = contactNames.get(digits);
+                if (contactName)
+                    conv.name = contactName;
+            }
+            // 4. Enrich with activation and sort by recency
+            const conversations = [...conversationMap.values()]
+                .map((c) => ({
+                ...c,
+                activation: c.type === "group"
+                    ? (resolveChannelGroupActivation({
+                        cfg,
+                        channel: "whatsapp",
+                        groupId: c.jid,
+                        accountId,
+                    }) ?? "mention")
+                    : undefined,
+            }))
+                .sort((a, b) => (b.lastMessageTimestamp ?? 0) - (a.lastMessageTimestamp ?? 0));
+            respond(true, { conversations });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
+    "whatsapp.messages": async ({ respond, params }) => {
+        if (!validateWhatsAppMessagesParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid whatsapp.messages params: ${formatValidationErrors(validateWhatsAppMessagesParams.errors)}`));
+            return;
+        }
+        const accountId = normalizeAccountId(params.accountId);
+        const jid = params.jid;
+        const limit = params.limit ?? 50;
+        try {
+            const cfg = loadConfig();
+            const { storePath, store } = loadCombinedSessionStoreForGateway(cfg);
+            // Find the session matching this JID
+            const matched = findSessionForJid(store, jid, accountId);
+            const matchedSessionId = matched?.entry.sessionId;
+            const matchedSessionFile = matched?.entry.sessionFile;
+            if (!matchedSessionId) {
+                respond(true, { messages: [] });
+                return;
+            }
+            // Read transcript and transform to WhatsApp message format
+            const rawMessages = readSessionMessages(matchedSessionId, storePath, matchedSessionFile);
+            const messages = [];
+            for (const raw of rawMessages) {
+                const msg = raw;
+                if (!msg.role || (msg.role !== "user" && msg.role !== "assistant"))
+                    continue;
+                let text = extractTextFromTranscriptMessage(msg);
+                if (!text)
+                    continue;
+                const fromMe = msg.role === "assistant";
+                let sender = "";
+                let senderName;
+                if (msg.role === "user") {
+                    // Strip envelope header (e.g. "[WhatsApp 2026-03-05 10:30]")
+                    text = stripEnvelope(text);
+                    // Extract sender from [from: ...] tag in group messages
+                    const extracted = extractSenderFromBody(text);
+                    text = extracted.cleanBody;
+                    sender = extracted.sender;
+                    senderName = extracted.senderName;
+                }
+                if (!text.trim())
+                    continue;
+                messages.push({
+                    id: `${matchedSessionId}-${messages.length}`,
+                    sender,
+                    senderName,
+                    body: text,
+                    timestamp: msg.timestamp ? Math.floor(msg.timestamp / 1000) : 0,
+                    fromMe,
+                });
+            }
+            // Return the most recent N messages
+            const limited = messages.slice(-limit);
+            respond(true, { messages: limited });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
+    "whatsapp.groupInfo": async ({ respond, params }) => {
+        if (!validateWhatsAppGroupInfoParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid whatsapp.groupInfo params: ${formatValidationErrors(validateWhatsAppGroupInfoParams.errors)}`));
+            return;
+        }
+        const accountId = normalizeAccountId(params.accountId);
+        const jid = params.jid;
+        const cfg = loadConfig();
+        const activation = resolveChannelGroupActivation({ cfg, channel: "whatsapp", groupId: jid, accountId }) ??
+            "mention";
+        // Try live Baileys metadata first (has participants)
+        try {
+            const { listener } = requireActiveWebListener(accountId);
+            if (listener.getGroupMetadata) {
+                const meta = await listener.getGroupMetadata(jid);
+                // Update stored subject if it changed
+                const { storePath, store } = loadCombinedSessionStoreForGateway(cfg);
+                const matched = findSessionForJid(store, jid, accountId);
+                if (matched && meta.subject && matched.entry.subject !== meta.subject) {
+                    updateSessionStore(storePath, (current) => {
+                        const entry = current[matched.key];
+                        if (entry)
+                            entry.subject = meta.subject;
+                    }).catch(() => { });
+                }
+                respond(true, { ...meta, activation });
+                return;
+            }
+        }
+        catch {
+            // Baileys unavailable — fall through to session store
+        }
+        // Fallback: session store data (no participants, but at least subject + activation)
+        try {
+            const { store } = loadCombinedSessionStoreForGateway(cfg);
+            const matched = findSessionForJid(store, jid, accountId);
+            respond(true, {
+                subject: matched?.entry.subject ?? matched?.entry.displayName ?? jid,
+                participants: [],
+                activation,
+            });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
+    "whatsapp.setActivation": async ({ respond, params }) => {
+        if (!validateWhatsAppSetActivationParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid whatsapp.setActivation params: ${formatValidationErrors(validateWhatsAppSetActivationParams.errors)}`));
+            return;
+        }
+        const accountId = normalizeAccountId(params.accountId);
+        try {
+            const cfg = loadConfig();
+            if (!cfg.channels)
+                cfg.channels = {};
+            if (!cfg.channels.whatsapp)
+                cfg.channels.whatsapp = {};
+            const wa = cfg.channels.whatsapp;
+            if (accountId !== "default") {
+                if (!wa.accounts)
+                    wa.accounts = {};
+                const accounts = wa.accounts;
+                if (!accounts[accountId])
+                    accounts[accountId] = {};
+                if (!accounts[accountId].groups)
+                    accounts[accountId].groups = {};
+                const groups = accounts[accountId].groups;
+                groups[params.jid] = {
+                    ...groups[params.jid],
+                    activation: params.activation,
+                };
+            }
+            else {
+                if (!wa.groups)
+                    wa.groups = {};
+                const groups = wa.groups;
+                groups[params.jid] = {
+                    ...groups[params.jid],
+                    activation: params.activation,
+                };
+            }
+            await writeConfigFile(cfg);
+            respond(true, { ok: true });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
+    "whatsapp.sendMessage": async ({ respond, params }) => {
+        if (!validateWhatsAppSendMessageParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid whatsapp.sendMessage params: ${formatValidationErrors(validateWhatsAppSendMessageParams.errors)}`));
+            return;
+        }
+        const accountId = normalizeAccountId(params.accountId);
+        try {
+            const { listener } = requireActiveWebListener(accountId);
+            const result = await listener.sendMessage(params.jid, params.body);
+            respond(true, { id: result.messageId, timestamp: Date.now() });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
+};