@rubytech/taskmaster 1.0.63 → 1.0.65

package/dist/agents/tools/message-history-tool.js

@@ -0,0 +1,436 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { resolveAgentWorkspaceDir, resolveSessionAgentId } from "../agent-scope.js";
+import { jsonResult, readNumberParam, readStringParam } from "./common.js";
+/**
+ * Schema for the message_history tool.
+ *
+ * - source: Identifies whose conversation to retrieve.
+ *   "current" (default) resolves from the agent's own session key.
+ *   "admin" reads admin/webchat conversations.
+ *   A phone number (e.g. "+447857934268") reads that user's DM archive.
+ *   A group ID reads group conversation archive.
+ *   "discover" lists available conversation sources.
+ *   "all" retrieves messages across all accessible conversations.
+ *
+ * - limit: Number of messages to return (default 30, max 500).
+ *
+ * - date: Optional YYYY-MM-DD filter. Without it, returns the most recent messages.
+ * - search: Case-insensitive substring filter on message text.
+ * - after/before: Time-range filter (HH:MM) within a date.
+ * - channel: Filter by channel (e.g. "whatsapp", "webchat", "imessage").
+ */
+const MessageHistorySchema = Type.Object({
+    source: Type.Optional(Type.String({
+        description: 'Whose conversation to retrieve: "current" (this session, default), "admin" (admin/webchat), ' +
+            'a phone number (e.g. "+447857934268") for a WhatsApp DM, a group JID for group chat, ' +
+            '"discover" to list available conversations, or "all" for messages across all conversations.',
+    })),
+    limit: Type.Optional(Type.Number({
+        description: "Number of messages to return (default 30, max 500). Returns the most recent.",
+        minimum: 1,
+        maximum: 500,
+    })),
+    date: Type.Optional(Type.String({
+        description: "Filter to a specific date (YYYY-MM-DD). Without this, returns the most recent messages across all dates.",
+    })),
+    search: Type.Optional(Type.String({
+        description: "Case-insensitive text search. Only messages containing this substring are returned.",
+    })),
+    after: Type.Optional(Type.String({
+        description: 'Include only messages at or after this time (HH:MM, 24h format). Requires "date" to be set.',
+    })),
+    before: Type.Optional(Type.String({
+        description: 'Include only messages before this time (HH:MM, 24h format). Requires "date" to be set.',
+    })),
+    channel: Type.Optional(Type.String({
+        description: 'Filter messages by channel (e.g. "whatsapp", "webchat", "imessage"). Only works for archives written after channel tagging was enabled.',
+    })),
+});
+const DATE_HEADER = /^## (\d{4}-\d{2}-\d{2})\s*$/;
+// Captures: time, role, optional [channel] tag at end of line
+const MESSAGE_HEADER = /^### (\d{2}:\d{2}) — (.+?)(?:\s+\[(\w+)\])?\s*$/;
+/**
+ * Parse a conversation archive markdown file into structured messages.
+ * The archive format is:
+ *
+ * ```
+ * ## 2026-02-18
+ *
+ * ### 09:43 — Admin
+ * Message text here.
+ *
+ * ### 09:44 — Assistant
+ * Response text here.
+ * ```
+ */
+export function parseConversationArchive(content) {
+    const lines = content.split(/\r?\n/);
+    const messages = [];
+    let currentDate = "";
+    let currentTime = "";
+    let currentRole = "";
+    let currentChannel;
+    let currentTextLines = [];
+    function flush() {
+        if (currentDate && currentTime && currentRole) {
+            const msg = {
+                date: currentDate,
+                time: currentTime,
+                role: currentRole,
+                text: currentTextLines.join("\n").trim(),
+            };
+            if (currentChannel)
+                msg.channel = currentChannel;
+            messages.push(msg);
+        }
+        currentTime = "";
+        currentRole = "";
+        currentChannel = undefined;
+        currentTextLines = [];
+    }
+    for (const line of lines) {
+        const dateMatch = line.match(DATE_HEADER);
+        if (dateMatch) {
+            flush();
+            currentDate = dateMatch[1];
+            continue;
+        }
+        const msgMatch = line.match(MESSAGE_HEADER);
+        if (msgMatch) {
+            flush();
+            currentTime = msgMatch[1];
+            currentRole = msgMatch[2];
+            currentChannel = msgMatch[3] ?? undefined;
+            continue;
+        }
+        // Accumulate text lines for the current message
+        if (currentRole) {
+            currentTextLines.push(line);
+        }
+    }
+    // Flush final message
+    flush();
+    return messages;
+}
+// ---------------------------------------------------------------------------
+// File resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the memory subdirectory for a given source identifier.
+ */
+function resolveArchiveSubdir(params) {
+    const { source, sessionKey, isAdminAgent } = params;
+    if (source === "admin") {
+        return { subdir: "admin" };
+    }
+    // Phone number — DM archive
+    if (source.startsWith("+")) {
+        const subdir = isAdminAgent ? "admin" : `users/${source}`;
+        return { subdir };
+    }
+    // Group JID
+    if (source.includes("@g.us")) {
+        return { subdir: `groups/${source}` };
+    }
+    // "current" — resolve from session key
+    if (source === "current" || !source) {
+        if (!sessionKey) {
+            return { subdir: "", error: "no session key available to resolve current conversation" };
+        }
+        const parts = sessionKey.toLowerCase().split(":").filter(Boolean);
+        // admin webchat: agent:{agentId}:main
+        if (parts.length === 3 && parts[0] === "agent" && parts[2] === "main") {
+            return { subdir: "admin" };
+        }
+        // DM: agent:{agentId}:dm:{peer} or agent:{agentId}:{channel}:dm:{peer}
+        if (parts.length >= 4 && parts[2] === "dm") {
+            const peer = parts.slice(3).join(":");
+            return { subdir: isAdminAgent ? "admin" : `users/${peer}` };
+        }
+        if (parts.length >= 5 && parts[3] === "dm") {
+            const peer = parts.slice(4).join(":");
+            return { subdir: isAdminAgent ? "admin" : `users/${peer}` };
+        }
+        // Group: agent:{agentId}:{channel}:group:{groupId}
+        if (parts.length >= 5 && parts[3] === "group") {
+            const groupId = parts.slice(4).join(":");
+            return { subdir: `groups/${groupId}` };
+        }
+        return {
+            subdir: "",
+            error: `cannot resolve conversation source from session key: ${sessionKey}`,
+        };
+    }
+    return {
+        subdir: "",
+        error: `unrecognised source: "${source}". Use "current", "admin", a phone number, or a group JID.`,
+    };
+}
+/**
+ * List conversation archive files in a directory, sorted newest first.
+ */
+async function listArchiveFiles(conversationsDir) {
+    try {
+        const entries = await fs.readdir(conversationsDir);
+        const mdFiles = entries
+            .filter((e) => e.endsWith(".md"))
+            .sort()
+            .reverse();
+        return mdFiles.map((f) => path.join(conversationsDir, f));
+    }
+    catch {
+        return [];
+    }
+}
+function applyFilters(messages, filters) {
+    let result = messages;
+    if (filters.dateFilter) {
+        const d = filters.dateFilter;
+        result = result.filter((m) => m.date === d);
+    }
+    if (filters.searchFilter) {
+        const s = filters.searchFilter.toLowerCase();
+        result = result.filter((m) => m.text.toLowerCase().includes(s));
+    }
+    if (filters.afterFilter) {
+        const a = filters.afterFilter;
+        result = result.filter((m) => m.time >= a);
+    }
+    if (filters.beforeFilter) {
+        const b = filters.beforeFilter;
+        result = result.filter((m) => m.time < b);
+    }
+    if (filters.channelFilter) {
+        const c = filters.channelFilter.toLowerCase();
+        result = result.filter((m) => m.channel?.toLowerCase() === c);
+    }
+    return result;
+}
+/**
+ * Scan memory directory for available conversation sources.
+ * Admin agents see admin/, users/*, groups/*.
+ * Public agents see users/*.
+ */
+async function discoverSources(params) {
+    const { memoryDir, isAdminAgent } = params;
+    const sources = [];
+    // Admin conversations
+    if (isAdminAgent) {
+        const adminConvDir = path.join(memoryDir, "admin", "conversations");
+        const adminFiles = await listArchiveFiles(adminConvDir);
+        if (adminFiles.length > 0) {
+            sources.push({
+                source: "admin",
+                type: "admin",
+                label: "Admin / Webchat",
+                lastArchive: path.basename(adminFiles[0], ".md"),
+            });
+        }
+    }
+    // User conversations
+    const usersDir = path.join(memoryDir, "users");
+    try {
+        const userEntries = await fs.readdir(usersDir, { withFileTypes: true });
+        for (const entry of userEntries) {
+            if (!entry.isDirectory())
+                continue;
+            const convDir = path.join(usersDir, entry.name, "conversations");
+            const files = await listArchiveFiles(convDir);
+            if (files.length > 0) {
+                sources.push({
+                    source: entry.name,
+                    type: "user",
+                    label: entry.name,
+                    lastArchive: path.basename(files[0], ".md"),
+                });
+            }
+        }
+    }
+    catch {
+        // users/ doesn't exist
+    }
+    // Group conversations
+    const groupsDir = path.join(memoryDir, "groups");
+    try {
+        const groupEntries = await fs.readdir(groupsDir, { withFileTypes: true });
+        for (const entry of groupEntries) {
+            if (!entry.isDirectory())
+                continue;
+            const convDir = path.join(groupsDir, entry.name, "conversations");
+            const files = await listArchiveFiles(convDir);
+            if (files.length > 0) {
+                sources.push({
+                    source: entry.name,
+                    type: "group",
+                    label: entry.name,
+                    lastArchive: path.basename(files[0], ".md"),
+                });
+            }
+        }
+    }
+    catch {
+        // groups/ doesn't exist
+    }
+    return sources;
+}
+async function readAllConversations(params) {
+    const sources = await discoverSources({
+        memoryDir: params.memoryDir,
+        isAdminAgent: params.isAdminAgent,
+    });
+    const all = [];
+    for (const src of sources) {
+        let convDir;
+        if (src.type === "admin") {
+            convDir = path.join(params.memoryDir, "admin", "conversations");
+        }
+        else if (src.type === "user") {
+            convDir = path.join(params.memoryDir, "users", src.source, "conversations");
+        }
+        else {
+            convDir = path.join(params.memoryDir, "groups", src.source, "conversations");
+        }
+        const archiveFiles = await listArchiveFiles(convDir);
+        for (const filePath of archiveFiles) {
+            try {
+                const content = await fs.readFile(filePath, "utf-8");
+                const parsed = parseConversationArchive(content);
+                const filtered = applyFilters(parsed, params.filters);
+                for (const m of filtered) {
+                    all.push({ ...m, source: src.source });
+                }
+            }
+            catch {
+                // skip unreadable
+            }
+        }
+    }
+    // Sort by date+time descending, take the most recent N, then reverse to chronological
+    all.sort((a, b) => {
+        const cmp = `${a.date}T${a.time}`.localeCompare(`${b.date}T${b.time}`);
+        return -cmp; // newest first
+    });
+    const sliced = all.slice(0, params.clampedLimit);
+    sliced.reverse(); // back to chronological
+    return sliced;
+}
+// ---------------------------------------------------------------------------
+// Tool factory
+// ---------------------------------------------------------------------------
+export function createMessageHistoryTool(options) {
+    const cfg = options.config;
+    if (!cfg)
+        return null;
+    const agentId = resolveSessionAgentId({
+        sessionKey: options.agentSessionKey,
+        config: cfg,
+    });
+    const agentConfig = cfg?.agents?.list?.find((a) => a.id?.toLowerCase() === agentId?.toLowerCase());
+    const isAdminAgent = agentConfig?.tools?.profile === "full" || agentConfig?.default === true;
+    return {
+        label: "Message History",
+        name: "message_history",
+        description: "Retrieve recent messages from conversation archives with accurate timestamps. " +
+            "Use this to look up what was said in any conversation — current session, admin/webchat, " +
+            "a specific WhatsApp DM (by phone number), or a group chat (by group JID). " +
+            'Pass source="discover" to list all available conversations, or source="all" to get ' +
+            "messages across all conversations. Supports text search, time-range, and channel filtering.",
+        parameters: MessageHistorySchema,
+        execute: async (_toolCallId, params) => {
+            const p = params;
+            const rawSource = readStringParam(p, "source") ?? "current";
+            const limit = readNumberParam(p, "limit") ?? 30;
+            const dateFilter = readStringParam(p, "date");
+            const searchFilter = readStringParam(p, "search");
+            const afterFilter = readStringParam(p, "after");
+            const beforeFilter = readStringParam(p, "before");
+            const channelFilter = readStringParam(p, "channel");
+            const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+            if (!workspaceDir) {
+                return jsonResult({ messages: [], error: "no workspace directory configured" });
+            }
+            const memoryDir = path.join(workspaceDir, "memory");
+            const clampedLimit = Math.min(Math.max(1, limit), 500);
+            const filters = {
+                dateFilter,
+                searchFilter,
+                afterFilter,
+                beforeFilter,
+                channelFilter,
+            };
+            // -- Discovery mode --
+            if (rawSource === "discover") {
+                const sources = await discoverSources({ memoryDir, isAdminAgent });
+                return jsonResult({
+                    mode: "discover",
+                    conversations: sources,
+                    total: sources.length,
+                });
+            }
+            // -- Aggregate mode --
+            if (rawSource === "all") {
+                const messages = await readAllConversations({
+                    memoryDir,
+                    isAdminAgent,
+                    clampedLimit,
+                    filters,
+                });
+                return jsonResult({
+                    source: "all",
+                    messages,
+                    total: messages.length,
+                    ...(dateFilter ? { dateFilter } : {}),
+                    ...(searchFilter ? { searchFilter } : {}),
+                    ...(channelFilter ? { channelFilter } : {}),
+                });
+            }
+            // -- Single-source mode --
+            const { subdir, error: subdirError } = resolveArchiveSubdir({
+                source: rawSource,
+                sessionKey: options.agentSessionKey,
+                isAdminAgent,
+            });
+            if (subdirError || !subdir) {
+                return jsonResult({ messages: [], error: subdirError });
+            }
+            const conversationsDir = path.join(memoryDir, subdir, "conversations");
+            const archiveFiles = await listArchiveFiles(conversationsDir);
+            if (archiveFiles.length === 0) {
+                return jsonResult({
+                    messages: [],
+                    source: rawSource,
+                    info: `no conversation archives found in ${subdir}/conversations/`,
+                });
+            }
+            // Collect messages from archive files (newest files first)
+            const allMessages = [];
+            for (const filePath of archiveFiles) {
+                try {
+                    const content = await fs.readFile(filePath, "utf-8");
+                    const parsed = parseConversationArchive(content);
+                    const filtered = applyFilters(parsed, filters);
+                    allMessages.unshift(...filtered);
+                    // If we have enough messages and no active filters require scanning all files, stop early
+                    if (!dateFilter && !searchFilter && allMessages.length >= clampedLimit) {
+                        break;
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+            // Return the most recent N messages
+            const result = allMessages.slice(-clampedLimit);
+            return jsonResult({
+                source: rawSource,
+                messages: result,
+                total: result.length,
+                ...(dateFilter ? { dateFilter } : {}),
+                ...(searchFilter ? { searchFilter } : {}),
+                ...(channelFilter ? { channelFilter } : {}),
+            });
+        },
+    };
+}

package/dist/agents/tools/sessions-history-tool.js

@@ -111,6 +111,7 @@ export function createSessionsHistoryTool(opts) {
                 params: {
                     sessionKey: resolvedKey,
                     limit,
+                    preserveEnvelopes: true,
                     ...(sessionIdParam ? { sessionId: sessionIdParam } : {}),
                 },
             }));

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.63",
-  "commit": "15a1377031320e9d047b3aba1bcc9124e5b707d0",
-  "builtAt": "2026-02-18T00:18:16.896Z"
+  "version": "1.0.65",
+  "commit": "d9051199b654984c06db2b45b2b5712191e13a2c",
+  "builtAt": "2026-02-18T16:08:39.070Z"
 }

package/dist/config/zod-schema.js

@@ -553,6 +553,16 @@ export const TaskmasterSchema = z
     })
         .strict()
         .optional(),
+    publicChat: z
+        .object({
+        enabled: z.boolean().optional(),
+        auth: z
+            .union([z.literal("anonymous"), z.literal("verified"), z.literal("choice")])
+            .optional(),
+        cookieTtlDays: z.number().int().positive().optional(),
+    })
+        .strict()
+        .optional(),
 })
     .strict()
     .superRefine((cfg, ctx) => {