@rubytech/taskmaster 1.16.3 → 1.17.4

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)));
+        }
+    },
+};

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

@@ -95,6 +95,12 @@ const BASE_METHODS = [
     "chat.history",
     "chat.abort",
     "chat.send",
+    // WhatsApp conversation browser
+    "whatsapp.conversations",
+    "whatsapp.messages",
+    "whatsapp.groupInfo",
+    "whatsapp.setActivation",
+    "whatsapp.sendMessage",
 ];
 export function listGatewayMethods() {
     const channelMethods = listChannelPlugins().flatMap((plugin) => plugin.gatewayMethods ?? []);

package/dist/gateway/server-methods.js

@@ -40,6 +40,7 @@ import { wifiHandlers } from "./server-methods/wifi.js";
 import { workspacesHandlers } from "./server-methods/workspaces.js";
 import { brandHandlers } from "./server-methods/brand.js";
 import { businessHandlers } from "./server-methods/business.js";
+import { whatsappConversationsHandlers } from "./server-methods/whatsapp-conversations.js";
 const ADMIN_SCOPE = "operator.admin";
 const READ_SCOPE = "operator.read";
 const WRITE_SCOPE = "operator.write";
@@ -109,6 +110,9 @@ const READ_METHODS = new Set([
     "memory.audit",
     "qr.generate",
     "business.openingHours.get",
+    "whatsapp.conversations",
+    "whatsapp.messages",
+    "whatsapp.groupInfo",
 ]);
 const WRITE_METHODS = new Set([
     "send",
@@ -124,6 +128,8 @@ const WRITE_METHODS = new Set([
     "node.invoke",
     "chat.send",
     "chat.abort",
+    "whatsapp.setActivation",
+    "whatsapp.sendMessage",
 ]);
 function authorizeGatewayMethod(method, client) {
     // Access methods bypass all scope checks — needed before PIN login
@@ -250,6 +256,7 @@ export const coreGatewayHandlers = {
     ...networkHandlers,
     ...tailscaleHandlers,
     ...wifiHandlers,
+    ...whatsappConversationsHandlers,
 };
 export async function handleGatewayRequest(opts) {
     const { req, respond, client, isWebchatConnect, context } = opts;

package/dist/gateway/server.impl.js

@@ -10,7 +10,7 @@ import { CONFIG_PATH_TASKMASTER, isNixMode, loadConfig, migrateLegacyConfig, rea
 import { VERSION } from "../version.js";
 import { isDiagnosticsEnabled } from "../infra/diagnostic-events.js";
 import { logAcceptedEnvOption } from "../infra/env.js";
-import { reconcileAgentContactTools, reconcileBeaglePublicTools, reconcileQrGenerateTool, reconcileStaleToolEntries, } from "../config/agent-tools-reconcile.js";
+import { reconcileAgentContactTools, reconcileBeaglePublicTools, reconcileControlPanelTools, reconcileQrGenerateTool, reconcileStaleToolEntries, } from "../config/agent-tools-reconcile.js";
 import { applyPluginAutoEnable } from "../config/plugin-auto-enable.js";
 import { clearAgentRunContext, onAgentEvent } from "../infra/agent-events.js";
 import { onHeartbeatEvent } from "../infra/heartbeat-events.js";
@@ -198,6 +198,21 @@ export async function startGatewayServer(port = 18789, opts = {}) {
             log.warn(`gateway: failed to persist qr_generate tool reconciliation: ${String(err)}`);
         }
     }
+    // Upgrade admin agents from individual control-panel tools to group:control-panel.
+    // Agents set up before the group existed miss tools added to it later (e.g. logs_read).
+    const cpReconcile = reconcileControlPanelTools({ config: configSnapshot.config });
+    if (cpReconcile.changes.length > 0) {
+        try {
+            await writeConfigFile(cpReconcile.config);
+            configSnapshot = await readConfigFileSnapshot();
+            log.info(`gateway: reconciled control-panel tools:\n${cpReconcile.changes
+                .map((entry) => `- ${entry}`)
+                .join("\n")}`);
+        }
+        catch (err) {
+            log.warn(`gateway: failed to persist control-panel tools reconciliation: ${String(err)}`);
+        }
+    }
     // Stamp config with running version on startup so upgrades keep the stamp current.
     const storedVersion = configSnapshot.config.meta?.lastTouchedVersion;
     if (configSnapshot.exists && storedVersion !== VERSION) {
@@ -475,11 +490,13 @@ export async function startGatewayServer(port = 18789, opts = {}) {
         if (!bundledSkillsDir)
             return;
         try {
+            const workspaceIds = Object.keys(cfgAtStart.workspaces ?? {});
+            const accountIds = workspaceIds.length > 0 ? workspaceIds : [DEFAULT_ACCOUNT_ID];
             const seeded = await seedPreloadedCronJobs({
                 bundledSkillsDir,
                 trackerPath: DEFAULT_SEED_TRACKER_PATH,
                 cronService: cron,
-                defaultAccountId: DEFAULT_ACCOUNT_ID,
+                accountIds,
             });
             if (seeded > 0) {
                 logCron.info(`cron: seeded ${seeded} preloaded job(s)`);

package/dist/gateway/sessions-patch.js

@@ -274,7 +274,7 @@ export async function applySessionsPatchToStore(params) {
         else if (raw !== undefined) {
             const normalized = normalizeGroupActivation(String(raw));
             if (!normalized) {
-                return invalid('invalid groupActivation (use "mention"|"always")');
+                return invalid('invalid groupActivation (use "mention"|"always"|"off")');
             }
             next.groupActivation = normalized;
         }

package/dist/hooks/bundled/ride-dispatch/HOOK.md

@@ -7,7 +7,7 @@ metadata:
     "taskmaster":
       {
         "emoji": "🚕",
-        "events": ["memory:add", "message:inbound"],
+        "events": ["memory:add", "message:before-dispatch"],
         "requires": { "config": ["workspace.dir"] },
         "install": [{ "id": "bundled", "kind": "bundled", "label": "Bundled with Taskmaster" }],
       },
@@ -28,13 +28,13 @@ When the public agent writes a file matching `shared/dispatch/{jobId}-{phase}.md
 2. **Dispatches to admin agent** in a session scoped to the booking (`ride-{jobId}`)
 3. **Admin agent autonomously processes** — contacts drivers, generates payment links, or finalises bookings
 
-### Driver Replies (message:inbound)
+### Driver Replies (message:before-dispatch)
 
-When a driver replies on WhatsApp (routed to the public agent's DM session):
+Before a WhatsApp DM is dispatched to the public agent's LLM:
 
 1. **Checks the active negotiation index** at `shared/active-negotiations/{phone}.md`
-2. **If the driver has an active negotiation**, dispatches their message to the admin's ride session for that job
-3. **If no active negotiation**, ignores the message (normal public agent handling)
+2. **If the driver has an active negotiation**, sets `event.suppress = true` and dispatches the reply to the admin's ride session — the public agent never sees the message
+3. **If no active negotiation**, does nothing — the message proceeds normally to the public agent
 
 ## Why This Exists
 
@@ -44,7 +44,8 @@ The public agent must not have `contact_lookup` or `message` tools — exposing
 
 - Only fires for **Beagle Zanzibar agents** (detected by `beagle` in agent ID)
 - **Deduplicates** — same dispatch file within 30 seconds is ignored
-- **Non-blocking** — dispatch is fire-and-forget so neither agent's reply is delayed
+- **Driver suppression** — driver replies set `event.suppress = true` so the public agent's LLM is never invoked for driver messages
+- **Non-blocking** — admin dispatch is fire-and-forget after suppression is set
 - Admin agent uses `contact_lookup` → `message` → `memory_write` for driver outreach
 - Admin agent uses `message` to inject results (offers, payment links, driver details) into tourist's conversation via cross-agent echo