@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/gateway/session-utils.fs.js

@@ -1,20 +1,60 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { resolveSessionTranscriptPath } from "../config/sessions.js";
+import { resolveSessionFilePath, resolveSessionTranscriptPath, resolveSessionTranscriptPathInDir, } from "../config/sessions.js";
 import { resolveRequiredHomeDir } from "../infra/home-dir.js";
+import { hasInterSessionUserProvenance } from "../sessions/input-provenance.js";
 import { extractToolCallNames, hasToolCall } from "../utils/transcript-tools.js";
 import { stripEnvelope } from "./chat-sanitize.js";
+const sessionTitleFieldsCache = new Map();
+const MAX_SESSION_TITLE_FIELDS_CACHE_ENTRIES = 5000;
+function readSessionTitleFieldsCacheKey(filePath, opts) {
+    const includeInterSession = opts?.includeInterSession === true ? "1" : "0";
+    return `${filePath}\t${includeInterSession}`;
+}
+function getCachedSessionTitleFields(cacheKey, stat) {
+    const cached = sessionTitleFieldsCache.get(cacheKey);
+    if (!cached) {
+        return null;
+    }
+    if (cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) {
+        sessionTitleFieldsCache.delete(cacheKey);
+        return null;
+    }
+    // LRU bump
+    sessionTitleFieldsCache.delete(cacheKey);
+    sessionTitleFieldsCache.set(cacheKey, cached);
+    return {
+        firstUserMessage: cached.firstUserMessage,
+        lastMessagePreview: cached.lastMessagePreview,
+    };
+}
+function setCachedSessionTitleFields(cacheKey, stat, value) {
+    sessionTitleFieldsCache.set(cacheKey, {
+        ...value,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+    });
+    while (sessionTitleFieldsCache.size > MAX_SESSION_TITLE_FIELDS_CACHE_ENTRIES) {
+        const oldestKey = sessionTitleFieldsCache.keys().next().value;
+        if (typeof oldestKey !== "string" || !oldestKey) {
+            break;
+        }
+        sessionTitleFieldsCache.delete(oldestKey);
+    }
+}
 export function readSessionMessages(sessionId, storePath, sessionFile) {
     const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile);
     const filePath = candidates.find((p) => fs.existsSync(p));
-    if (!filePath)
+    if (!filePath) {
         return [];
+    }
     const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/);
     const messages = [];
     for (const line of lines) {
-        if (!line.trim())
+        if (!line.trim()) {
             continue;
+        }
         try {
             const parsed = JSON.parse(line);
             if (parsed?.message) {
@@ -45,18 +85,39 @@ export function readSessionMessages(sessionId, storePath, sessionFile) {
 }
 export function resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId) {
     const candidates = [];
-    if (sessionFile)
-        candidates.push(sessionFile);
+    const pushCandidate = (resolve) => {
+        try {
+            candidates.push(resolve());
+        }
+        catch {
+            // Ignore invalid paths/IDs and keep scanning other safe candidates.
+        }
+    };
     if (storePath) {
-        const dir = path.dirname(storePath);
-        candidates.push(path.join(dir, `${sessionId}.jsonl`));
+        const sessionsDir = path.dirname(storePath);
+        if (sessionFile) {
+            pushCandidate(() => resolveSessionFilePath(sessionId, { sessionFile }, { sessionsDir, agentId }));
+        }
+        pushCandidate(() => resolveSessionTranscriptPathInDir(sessionId, sessionsDir));
+    }
+    else if (sessionFile) {
+        if (agentId) {
+            pushCandidate(() => resolveSessionFilePath(sessionId, { sessionFile }, { agentId }));
+        }
+        else {
+            const trimmed = sessionFile.trim();
+            if (trimmed) {
+                candidates.push(path.resolve(trimmed));
+            }
+        }
     }
     if (agentId) {
-        candidates.push(resolveSessionTranscriptPath(sessionId, agentId));
+        pushCandidate(() => resolveSessionTranscriptPath(sessionId, agentId));
     }
     const home = resolveRequiredHomeDir(process.env, os.homedir);
-    candidates.push(path.join(home, ".poolbot", "sessions", `${sessionId}.jsonl`));
-    return candidates;
+    const legacyDir = path.join(home, ".poolbot", "sessions");
+    pushCandidate(() => resolveSessionTranscriptPathInDir(sessionId, legacyDir));
+    return Array.from(new Set(candidates));
 }
 export function archiveFileOnDisk(filePath, reason) {
     const ts = new Date().toISOString().replaceAll(":", "-");
@@ -64,6 +125,76 @@ export function archiveFileOnDisk(filePath, reason) {
     fs.renameSync(filePath, archived);
     return archived;
 }
+/**
+ * Archives all transcript files for a given session.
+ * Best-effort: silently skips files that don't exist or fail to rename.
+ */
+export function archiveSessionTranscripts(opts) {
+    const archived = [];
+    for (const candidate of resolveSessionTranscriptCandidates(opts.sessionId, opts.storePath, opts.sessionFile, opts.agentId)) {
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+        try {
+            archived.push(archiveFileOnDisk(candidate, opts.reason));
+        }
+        catch {
+            // Best-effort.
+        }
+    }
+    return archived;
+}
+function restoreArchiveTimestamp(raw) {
+    const [datePart, timePart] = raw.split("T");
+    if (!datePart || !timePart) {
+        return raw;
+    }
+    return `${datePart}T${timePart.replace(/-/g, ":")}`;
+}
+function parseArchivedTimestamp(fileName, reason) {
+    const marker = `.${reason}.`;
+    const index = fileName.lastIndexOf(marker);
+    if (index < 0) {
+        return null;
+    }
+    const raw = fileName.slice(index + marker.length);
+    if (!raw) {
+        return null;
+    }
+    const timestamp = Date.parse(restoreArchiveTimestamp(raw));
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
+export async function cleanupArchivedSessionTranscripts(opts) {
+    if (!Number.isFinite(opts.olderThanMs) || opts.olderThanMs < 0) {
+        return { removed: 0, scanned: 0 };
+    }
+    const now = opts.nowMs ?? Date.now();
+    const reason = opts.reason ?? "deleted";
+    const directories = Array.from(new Set(opts.directories.map((dir) => path.resolve(dir))));
+    let removed = 0;
+    let scanned = 0;
+    for (const dir of directories) {
+        const entries = await fs.promises.readdir(dir).catch(() => []);
+        for (const entry of entries) {
+            const timestamp = parseArchivedTimestamp(entry, reason);
+            if (timestamp == null) {
+                continue;
+            }
+            scanned += 1;
+            if (now - timestamp <= opts.olderThanMs) {
+                continue;
+            }
+            const fullPath = path.join(dir, entry);
+            const stat = await fs.promises.stat(fullPath).catch(() => null);
+            if (!stat?.isFile()) {
+                continue;
+            }
+            await fs.promises.rm(fullPath).catch(() => undefined);
+            removed += 1;
+        }
+    }
+    return { removed, scanned };
+}
 function jsonUtf8Bytes(value) {
     try {
         return Buffer.byteLength(JSON.stringify(value), "utf8");
@@ -73,8 +204,9 @@ function jsonUtf8Bytes(value) {
     }
 }
 export function capArrayByJsonBytes(items, maxBytes) {
-    if (items.length === 0)
+    if (items.length === 0) {
         return { items, bytes: 2 };
+    }
     const parts = items.map((item) => jsonUtf8Bytes(item));
     let bytes = 2 + parts.reduce((a, b) => a + b, 0) + (items.length - 1);
     let start = 0;
@@ -86,113 +218,210 @@ export function capArrayByJsonBytes(items, maxBytes) {
     return { items: next, bytes };
 }
 const MAX_LINES_TO_SCAN = 10;
+export function readSessionTitleFieldsFromTranscript(sessionId, storePath, sessionFile, agentId, opts) {
+    const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
+    const filePath = candidates.find((p) => fs.existsSync(p));
+    if (!filePath) {
+        return { firstUserMessage: null, lastMessagePreview: null };
+    }
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        return { firstUserMessage: null, lastMessagePreview: null };
+    }
+    const cacheKey = readSessionTitleFieldsCacheKey(filePath, opts);
+    const cached = getCachedSessionTitleFields(cacheKey, stat);
+    if (cached) {
+        return cached;
+    }
+    if (stat.size === 0) {
+        const empty = { firstUserMessage: null, lastMessagePreview: null };
+        setCachedSessionTitleFields(cacheKey, stat, empty);
+        return empty;
+    }
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const size = stat.size;
+        // Head (first user message)
+        let firstUserMessage = null;
+        try {
+            const chunk = readTranscriptHeadChunk(fd);
+            if (chunk) {
+                firstUserMessage = extractFirstUserMessageFromTranscriptChunk(chunk, opts);
+            }
+        }
+        catch {
+            // ignore head read errors
+        }
+        // Tail (last message preview)
+        let lastMessagePreview = null;
+        try {
+            lastMessagePreview = readLastMessagePreviewFromOpenTranscript({ fd, size });
+        }
+        catch {
+            // ignore tail read errors
+        }
+        const result = { firstUserMessage, lastMessagePreview };
+        setCachedSessionTitleFields(cacheKey, stat, result);
+        return result;
+    }
+    catch {
+        return { firstUserMessage: null, lastMessagePreview: null };
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
 function extractTextFromContent(content) {
-    if (typeof content === "string")
+    if (typeof content === "string") {
         return content.trim() || null;
-    if (!Array.isArray(content))
+    }
+    if (!Array.isArray(content)) {
         return null;
+    }
     for (const part of content) {
-        if (!part || typeof part.text !== "string")
+        if (!part || typeof part.text !== "string") {
             continue;
+        }
         if (part.type === "text" || part.type === "output_text" || part.type === "input_text") {
             const trimmed = part.text.trim();
-            if (trimmed)
+            if (trimmed) {
                 return trimmed;
+            }
+        }
+    }
+    return null;
+}
+function readTranscriptHeadChunk(fd, maxBytes = 8192) {
+    const buf = Buffer.alloc(maxBytes);
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    if (bytesRead <= 0) {
+        return null;
+    }
+    return buf.toString("utf-8", 0, bytesRead);
+}
+function extractFirstUserMessageFromTranscriptChunk(chunk, opts) {
+    const lines = chunk.split(/\r?\n/).slice(0, MAX_LINES_TO_SCAN);
+    for (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(line);
+            const msg = parsed?.message;
+            if (msg?.role !== "user") {
+                continue;
+            }
+            if (opts?.includeInterSession !== true && hasInterSessionUserProvenance(msg)) {
+                continue;
+            }
+            const text = extractTextFromContent(msg.content);
+            if (text) {
+                return text;
+            }
+        }
+        catch {
+            // skip malformed lines
         }
     }
     return null;
 }
-export function readFirstUserMessageFromTranscript(sessionId, storePath, sessionFile, agentId) {
+export function readFirstUserMessageFromTranscript(sessionId, storePath, sessionFile, agentId, opts) {
     const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
     const filePath = candidates.find((p) => fs.existsSync(p));
-    if (!filePath)
+    if (!filePath) {
         return null;
+    }
     let fd = null;
     try {
         fd = fs.openSync(filePath, "r");
-        const buf = Buffer.alloc(8192);
-        const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
-        if (bytesRead === 0)
+        const chunk = readTranscriptHeadChunk(fd);
+        if (!chunk) {
             return null;
-        const chunk = buf.toString("utf-8", 0, bytesRead);
-        const lines = chunk.split(/\r?\n/).slice(0, MAX_LINES_TO_SCAN);
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                const parsed = JSON.parse(line);
-                const msg = parsed?.message;
-                if (msg?.role === "user") {
-                    const text = extractTextFromContent(msg.content);
-                    if (text)
-                        return text;
-                }
-            }
-            catch {
-                // skip malformed lines
-            }
         }
+        return extractFirstUserMessageFromTranscriptChunk(chunk, opts);
     }
     catch {
         // file read error
     }
     finally {
-        if (fd !== null)
+        if (fd !== null) {
             fs.closeSync(fd);
+        }
     }
     return null;
 }
 const LAST_MSG_MAX_BYTES = 16384;
 const LAST_MSG_MAX_LINES = 20;
+function readLastMessagePreviewFromOpenTranscript(params) {
+    const readStart = Math.max(0, params.size - LAST_MSG_MAX_BYTES);
+    const readLen = Math.min(params.size, LAST_MSG_MAX_BYTES);
+    const buf = Buffer.alloc(readLen);
+    fs.readSync(params.fd, buf, 0, readLen, readStart);
+    const chunk = buf.toString("utf-8");
+    const lines = chunk.split(/\r?\n/).filter((l) => l.trim());
+    const tailLines = lines.slice(-LAST_MSG_MAX_LINES);
+    for (let i = tailLines.length - 1; i >= 0; i--) {
+        const line = tailLines[i];
+        try {
+            const parsed = JSON.parse(line);
+            const msg = parsed?.message;
+            if (msg?.role !== "user" && msg?.role !== "assistant") {
+                continue;
+            }
+            const text = extractTextFromContent(msg.content);
+            if (text) {
+                return text;
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return null;
+}
 export function readLastMessagePreviewFromTranscript(sessionId, storePath, sessionFile, agentId) {
     const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
     const filePath = candidates.find((p) => fs.existsSync(p));
-    if (!filePath)
+    if (!filePath) {
         return null;
+    }
     let fd = null;
     try {
         fd = fs.openSync(filePath, "r");
         const stat = fs.fstatSync(fd);
         const size = stat.size;
-        if (size === 0)
+        if (size === 0) {
             return null;
-        const readStart = Math.max(0, size - LAST_MSG_MAX_BYTES);
-        const readLen = Math.min(size, LAST_MSG_MAX_BYTES);
-        const buf = Buffer.alloc(readLen);
-        fs.readSync(fd, buf, 0, readLen, readStart);
-        const chunk = buf.toString("utf-8");
-        const lines = chunk.split(/\r?\n/).filter((l) => l.trim());
-        const tailLines = lines.slice(-LAST_MSG_MAX_LINES);
-        for (let i = tailLines.length - 1; i >= 0; i--) {
-            const line = tailLines[i];
-            try {
-                const parsed = JSON.parse(line);
-                const msg = parsed?.message;
-                if (msg?.role === "user" || msg?.role === "assistant") {
-                    const text = extractTextFromContent(msg.content);
-                    if (text)
-                        return text;
-                }
-            }
-            catch {
-                // skip malformed
-            }
         }
+        return readLastMessagePreviewFromOpenTranscript({ fd, size });
     }
     catch {
         // file error
     }
     finally {
-        if (fd !== null)
+        if (fd !== null) {
             fs.closeSync(fd);
+        }
     }
     return null;
 }
 const PREVIEW_READ_SIZES = [64 * 1024, 256 * 1024, 1024 * 1024];
 const PREVIEW_MAX_LINES = 200;
 function normalizeRole(role, isTool) {
-    if (isTool)
+    if (isTool) {
         return "tool";
+    }
     switch ((role ?? "").toLowerCase()) {
         case "user":
             return "user";
@@ -207,10 +436,12 @@ function normalizeRole(role, isTool) {
     }
 }
 function truncatePreviewText(text, maxChars) {
-    if (maxChars <= 0 || text.length <= maxChars)
+    if (maxChars <= 0 || text.length <= maxChars) {
         return text;
-    if (maxChars <= 3)
+    }
+    if (maxChars <= 3) {
         return text.slice(0, maxChars);
+    }
     return `${text.slice(0, maxChars - 3)}...`;
 }
 function extractPreviewText(message) {
@@ -239,12 +470,14 @@ function extractToolNames(message) {
     return extractToolCallNames(message);
 }
 function extractMediaSummary(message) {
-    if (!Array.isArray(message.content))
+    if (!Array.isArray(message.content)) {
         return null;
+    }
     for (const entry of message.content) {
         const raw = typeof entry?.type === "string" ? entry.type.trim().toLowerCase() : "";
-        if (!raw || raw === "text" || raw === "toolcall" || raw === "tool_call")
+        if (!raw || raw === "text" || raw === "toolcall" || raw === "tool_call") {
             continue;
+        }
         return `[${raw}]`;
     }
     return null;
@@ -261,26 +494,30 @@ function buildPreviewItems(messages, maxItems, maxChars) {
                 const shown = toolNames.slice(0, 2);
                 const overflow = toolNames.length - shown.length;
                 text = `call ${shown.join(", ")}`;
-                if (overflow > 0)
+                if (overflow > 0) {
                     text += ` +${overflow}`;
+                }
             }
         }
         if (!text) {
             text = extractMediaSummary(message);
         }
-        if (!text)
+        if (!text) {
             continue;
+        }
         let trimmed = text.trim();
-        if (!trimmed)
+        if (!trimmed) {
             continue;
+        }
         if (role === "user") {
             trimmed = stripEnvelope(trimmed);
         }
         trimmed = truncatePreviewText(trimmed, maxChars);
         items.push({ role, text: trimmed });
     }
-    if (items.length <= maxItems)
+    if (items.length <= maxItems) {
         return items;
+    }
     return items.slice(-maxItems);
 }
 function readRecentMessagesFromTranscript(filePath, maxMessages, readBytes) {
@@ -289,8 +526,9 @@ function readRecentMessagesFromTranscript(filePath, maxMessages, readBytes) {
         fd = fs.openSync(filePath, "r");
         const stat = fs.fstatSync(fd);
         const size = stat.size;
-        if (size === 0)
+        if (size === 0) {
             return [];
+        }
         const readStart = Math.max(0, size - readBytes);
         const readLen = Math.min(size, readBytes);
         const buf = Buffer.alloc(readLen);
@@ -306,8 +544,9 @@ function readRecentMessagesFromTranscript(filePath, maxMessages, readBytes) {
                 const msg = parsed?.message;
                 if (msg && typeof msg === "object") {
                     collected.push(msg);
-                    if (collected.length >= maxMessages)
+                    if (collected.length >= maxMessages) {
                         break;
+                    }
                 }
             }
             catch {
@@ -320,15 +559,17 @@ function readRecentMessagesFromTranscript(filePath, maxMessages, readBytes) {
         return [];
     }
     finally {
-        if (fd !== null)
+        if (fd !== null) {
             fs.closeSync(fd);
+        }
     }
 }
 export function readSessionPreviewItemsFromTranscript(sessionId, storePath, sessionFile, agentId, maxItems, maxChars) {
     const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile, agentId);
     const filePath = candidates.find((p) => fs.existsSync(p));
-    if (!filePath)
+    if (!filePath) {
         return [];
+    }
     const boundedItems = Math.max(1, Math.min(maxItems, 50));
     const boundedChars = Math.max(20, Math.min(maxChars, 2000));
     for (const readSize of PREVIEW_READ_SIZES) {