@rubytech/taskmaster 1.0.61 → 1.0.63

package/dist/infra/session-recovery.js

@@ -0,0 +1,381 @@
+/**
+ * Recovers orphaned session JSONL files that exist on disk but are not
+ * referenced by any session store entry (neither as a current session nor
+ * in any `previousSessions` array).
+ *
+ * This situation arises when daily/idle resets silently replaced session
+ * entries without archiving the previous session. The JSONL files were
+ * preserved on disk but the store lost track of them.
+ *
+ * The recovery runs once at gateway startup, is idempotent, and classifies
+ * each orphan by reading its first user message to determine which session
+ * key it belongs to (cron, WhatsApp DM, or webchat main).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { updateSessionStore } from "../config/sessions.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("session-recovery");
+// ---------- Classification helpers ----------
+const CRON_PATTERN = /^\[cron:([0-9a-f-]{36})\b/i;
+const WHATSAPP_PATTERN = /^\[WhatsApp\s+(\+\d+)\b/i;
+/**
+ * Read the session header (first JSONL line) to get the timestamp,
+ * and the first user message to classify the channel.
+ */
+function classifyOrphan(filePath, agentId, knownSessionKeys) {
+    const uuid = path.basename(filePath, ".jsonl");
+    let headerTimestamp = 0;
+    let firstUserMessage = null;
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        // Read enough to cover the header + first few messages
+        const buf = Buffer.alloc(16384);
+        const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+        if (bytesRead === 0)
+            return null;
+        const chunk = buf.toString("utf-8", 0, bytesRead);
+        const lines = chunk.split(/\r?\n/).slice(0, 20);
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                // Session header line
+                if (parsed?.type === "session" && parsed?.timestamp) {
+                    const ts = typeof parsed.timestamp === "number"
+                        ? parsed.timestamp
+                        : new Date(parsed.timestamp).getTime();
+                    if (Number.isFinite(ts))
+                        headerTimestamp = ts;
+                }
+                // First user message
+                if (parsed?.type === "message" && !firstUserMessage) {
+                    const msg = parsed?.message;
+                    if (msg?.role === "user") {
+                        const content = msg.content;
+                        if (typeof content === "string") {
+                            firstUserMessage = content;
+                        }
+                        else if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block?.type === "text" && typeof block.text === "string") {
+                                    firstUserMessage = block.text;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (headerTimestamp && firstUserMessage)
+                    break;
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+    // Fall back to file mtime if no header timestamp
+    if (!headerTimestamp) {
+        try {
+            headerTimestamp = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            headerTimestamp = 0;
+        }
+    }
+    // Classify by first user message content
+    let sessionKey = null;
+    if (firstUserMessage) {
+        const cronMatch = firstUserMessage.match(CRON_PATTERN);
+        if (cronMatch) {
+            const cronId = cronMatch[1];
+            const candidate = `agent:${agentId}:cron:${cronId}`;
+            // Only assign to a cron key that exists in the store
+            sessionKey = knownSessionKeys.has(candidate) ? candidate : null;
+        }
+        if (!sessionKey) {
+            const waMatch = firstUserMessage.match(WHATSAPP_PATTERN);
+            if (waMatch) {
+                const phone = waMatch[1];
+                const candidate = `agent:${agentId}:dm:${phone}`;
+                sessionKey = knownSessionKeys.has(candidate) ? candidate : null;
+            }
+        }
+    }
+    // Default: assign to the agent's main webchat session
+    if (!sessionKey) {
+        const mainKey = `agent:${agentId}:main`;
+        if (knownSessionKeys.has(mainKey)) {
+            sessionKey = mainKey;
+        }
+    }
+    return { uuid, filePath, headerTimestamp, sessionKey };
+}
+// ---------- Main recovery ----------
+export async function recoverOrphanedSessions(params) {
+    const stateDir = params?.stateDir ?? resolveStateDir();
+    const agentsDir = path.join(stateDir, "agents");
+    if (!fs.existsSync(agentsDir)) {
+        return { recovered: 0, agents: 0 };
+    }
+    let totalRecovered = 0;
+    let agentsProcessed = 0;
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    }
+    catch {
+        return { recovered: 0, agents: 0 };
+    }
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const agentId = agentEntry.name;
+        const sessionsDir = path.join(agentsDir, agentId, "sessions");
+        const storePath = path.join(sessionsDir, "sessions.json");
+        if (!fs.existsSync(storePath))
+            continue;
+        // Load the store
+        let store;
+        try {
+            const raw = fs.readFileSync(storePath, "utf-8");
+            store = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        // Collect all referenced session IDs
+        const referencedIds = new Set();
+        const knownSessionKeys = new Set();
+        for (const [key, entry] of Object.entries(store)) {
+            knownSessionKeys.add(key);
+            if (entry.sessionId)
+                referencedIds.add(entry.sessionId);
+            if (Array.isArray(entry.previousSessions)) {
+                for (const prev of entry.previousSessions) {
+                    if (prev.sessionId)
+                        referencedIds.add(prev.sessionId);
+                }
+            }
+        }
+        // List JSONL files on disk
+        let files;
+        try {
+            files = fs
+                .readdirSync(sessionsDir)
+                .filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        // Find orphans
+        const orphans = [];
+        for (const file of files) {
+            const uuid = file.replace(".jsonl", "");
+            if (referencedIds.has(uuid))
+                continue;
+            const info = classifyOrphan(path.join(sessionsDir, file), agentId, knownSessionKeys);
+            if (info?.sessionKey) {
+                orphans.push(info);
+            }
+        }
+        if (orphans.length === 0)
+            continue;
+        agentsProcessed++;
+        // Group orphans by session key
+        const byKey = new Map();
+        for (const orphan of orphans) {
+            if (!orphan.sessionKey)
+                continue;
+            const group = byKey.get(orphan.sessionKey) ?? [];
+            group.push(orphan);
+            byKey.set(orphan.sessionKey, group);
+        }
+        // Update the store: prepend orphans to each entry's previousSessions
+        try {
+            await updateSessionStore(storePath, (currentStore) => {
+                for (const [sessionKey, orphanGroup] of byKey.entries()) {
+                    const entry = currentStore[sessionKey];
+                    if (!entry)
+                        continue;
+                    // Re-check: skip any that are now referenced (in case of concurrent update)
+                    const nowReferenced = new Set();
+                    if (entry.sessionId)
+                        nowReferenced.add(entry.sessionId);
+                    if (Array.isArray(entry.previousSessions)) {
+                        for (const prev of entry.previousSessions) {
+                            if (prev.sessionId)
+                                nowReferenced.add(prev.sessionId);
+                        }
+                    }
+                    const toAdd = orphanGroup
+                        .filter((o) => !nowReferenced.has(o.uuid))
+                        .sort((a, b) => a.headerTimestamp - b.headerTimestamp);
+                    if (toAdd.length === 0)
+                        continue;
+                    const existingPrev = entry.previousSessions ?? [];
+                    const newPrev = [
+                        ...toAdd.map((o) => ({
+                            sessionId: o.uuid,
+                            sessionFile: o.filePath,
+                            endedAt: o.headerTimestamp,
+                        })),
+                        ...existingPrev,
+                    ];
+                    entry.previousSessions = newPrev;
+                    totalRecovered += toAdd.length;
+                }
+            });
+        }
+        catch (err) {
+            log.warn(`failed to update store for agent ${agentId}: ${String(err)}`);
+        }
+    }
+    if (totalRecovered > 0) {
+        log.info(`recovered ${totalRecovered} orphaned session(s) across ${agentsProcessed} agent(s)`);
+    }
+    return { recovered: totalRecovered, agents: agentsProcessed };
+}
+// ---------- Base64 image stripping from JSONL transcripts ----------
+/**
+ * Returns true if a content block contains inline base64 image data
+ * that should have been stored as a physical file instead.
+ */
+function hasInlineBase64(block) {
+    if (block.type === "image") {
+        if (typeof block.data === "string" && block.data.length > 256)
+            return true;
+        const source = block.source;
+        if (source?.type === "base64" && typeof source.data === "string" && source.data.length > 256) {
+            return true;
+        }
+    }
+    if (block.type === "image_url") {
+        const imageUrl = block.image_url;
+        if (typeof imageUrl?.url === "string" && imageUrl.url.startsWith("data:"))
+            return true;
+    }
+    return false;
+}
+/**
+ * Replace base64 image blocks in a content array with text placeholders.
+ * Returns null if no changes were made.
+ */
+function stripBase64FromContent(content) {
+    let changed = false;
+    const result = content.map((block) => {
+        if (!block || typeof block !== "object")
+            return block;
+        const b = block;
+        if (!hasInlineBase64(b))
+            return block;
+        changed = true;
+        const mime = b.mimeType ??
+            b.media_type ??
+            b.source?.media_type ??
+            "image";
+        return { type: "text", text: `[${mime}]` };
+    });
+    return changed ? result : null;
+}
+/**
+ * Scans all JSONL transcript files across all agents and removes inline
+ * base64 image data, replacing with text placeholders.
+ *
+ * Idempotent — files with no base64 are left untouched.
+ */
+export async function stripBase64FromTranscripts(params) {
+    const stateDir = params?.stateDir ?? resolveStateDir();
+    const agentsDir = path.join(stateDir, "agents");
+    if (!fs.existsSync(agentsDir)) {
+        return { cleaned: 0, bytesReclaimed: 0 };
+    }
+    let totalCleaned = 0;
+    let totalBytesReclaimed = 0;
+    let agentEntries;
+    try {
+        agentEntries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    }
+    catch {
+        return { cleaned: 0, bytesReclaimed: 0 };
+    }
+    for (const agentEntry of agentEntries) {
+        if (!agentEntry.isDirectory())
+            continue;
+        const sessionsDir = path.join(agentsDir, agentEntry.name, "sessions");
+        let files;
+        try {
+            files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const filePath = path.join(sessionsDir, file);
+            let raw;
+            try {
+                raw = fs.readFileSync(filePath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const lines = raw.split(/\r?\n/);
+            let fileChanged = false;
+            const rewritten = [];
+            for (const line of lines) {
+                if (!line.trim()) {
+                    rewritten.push(line);
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    const msg = parsed?.message;
+                    if (msg && Array.isArray(msg.content)) {
+                        const stripped = stripBase64FromContent(msg.content);
+                        if (stripped) {
+                            parsed.message = { ...msg, content: stripped };
+                            rewritten.push(JSON.stringify(parsed));
+                            fileChanged = true;
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    // keep line as-is
+                }
+                rewritten.push(line);
+            }
+            if (!fileChanged)
+                continue;
+            const newContent = rewritten.join("\n");
+            const oldSize = Buffer.byteLength(raw, "utf-8");
+            const newSize = Buffer.byteLength(newContent, "utf-8");
+            try {
+                // Atomic write: write to tmp, then rename
+                const tmpPath = `${filePath}.tmp`;
+                fs.writeFileSync(tmpPath, newContent, "utf-8");
+                fs.renameSync(tmpPath, filePath);
+                totalCleaned++;
+                totalBytesReclaimed += oldSize - newSize;
+            }
+            catch (err) {
+                log.warn(`failed to clean ${file}: ${String(err)}`);
+            }
+        }
+    }
+    if (totalCleaned > 0) {
+        const mb = (totalBytesReclaimed / (1024 * 1024)).toFixed(1);
+        log.info(`stripped base64 images from ${totalCleaned} transcript(s), reclaimed ${mb} MB`);
+    }
+    return { cleaned: totalCleaned, bytesReclaimed: totalBytesReclaimed };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.61",
+  "version": "1.0.63",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"

package/taskmaster-docs/USER-GUIDE.md

@@ -242,6 +242,10 @@ You can send files to your assistant by dragging and dropping them onto the chat
 
 If your assistant is busy thinking, you can still type and send more messages. They appear immediately in the chat as normal messages and are delivered to your assistant in order once it finishes its current task.
 
+### Suggestion Chips
+
+After each response, a suggested follow-up appears as a clickable chip below the conversation. Tap it to send the suggestion, or type your own message — the chip disappears as soon as you start a new message. When you open a fresh chat session, a starter suggestion helps you begin the conversation.
+
 ### Model and Thinking Level
 
 Below the message box you'll see two dropdown selectors: