@cryptiklemur/lattice 1.43.6 → 1.43.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "1.43.6",
+  "version": "1.43.8",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",

package/server/src/handlers/session.ts

@@ -25,7 +25,7 @@ import {
   renameSession,
 } from "../project/session";
 import { getContextBreakdown } from "../project/context-breakdown";
-import { setActiveSession } from "./chat";
+import { setActiveSession, getActiveSession } from "./chat";
 import { setActiveProject } from "./fs";
 import { wasSessionInterrupted, clearInterruptedFlag, isSessionBusy, watchSessionLock, stopExternalSession, getBusyOwner } from "../project/sdk-bridge";
 import { log } from "../logger";
@@ -82,12 +82,14 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
 
   if (message.type === "session:history_page") {
     var pageMsg = message as { type: "session:history_page"; sessionId: string; before: number; limit: number };
-    var page = getSessionHistoryPage(pageMsg.sessionId, pageMsg.before, pageMsg.limit);
-    sendTo(clientId, {
-      type: "session:history_page_result",
-      sessionId: pageMsg.sessionId,
-      messages: page.messages,
-      hasMore: page.hasMore,
+    var activeSession = getActiveSession(clientId);
+    void getSessionHistoryPage(pageMsg.sessionId, pageMsg.before, pageMsg.limit, activeSession?.projectSlug).then(function (page) {
+      sendTo(clientId, {
+        type: "session:history_page_result",
+        sessionId: pageMsg.sessionId,
+        messages: page.messages,
+        hasMore: page.hasMore,
+      });
     });
     return;
   }
@@ -104,50 +106,43 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
     setActiveProject(clientId, activateMsg.projectSlug);
     watchSessionLock(activateMsg.sessionId);
+    var activateT0 = Date.now();
     void Promise.all([
-      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load session history: %O", err);
-        return null;
-      }),
-      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load session title: %O", err);
-        return null;
-      }),
-      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load session usage: %O", err);
-        return null;
-      }),
-      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load context breakdown: %O", err);
-        return null;
-      }),
+      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId),
+      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
     ]).then(function (results) {
-      try {
-        var interrupted = wasSessionInterrupted(activateMsg.sessionId);
-        if (interrupted) {
-          clearInterruptedFlag(activateMsg.sessionId);
-        }
-        var busy = isSessionBusy(activateMsg.sessionId);
-        var busyOwner = busy ? getBusyOwner(activateMsg.sessionId) : undefined;
-        var historyResult = results[0] || { messages: [], totalMessages: 0, hasMore: false };
-        sendTo(clientId, {
-          type: "session:history",
-          projectSlug: activateMsg.projectSlug,
-          sessionId: activateMsg.sessionId,
-          messages: historyResult.messages,
-          title: results[1],
-          interrupted: interrupted || undefined,
-          busy: busy || undefined,
-          busyOwner: busyOwner,
-          totalMessages: historyResult.totalMessages,
-          hasMore: historyResult.hasMore,
-        });
-      } catch (err) {
-        log.session("Error sending session history: %O", err);
-        sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
+      log.session("session:activate history+title: %dms", Date.now() - activateT0);
+      var historyResult = results[0];
+      var title = results[1];
+      var interrupted = wasSessionInterrupted(activateMsg.sessionId);
+      if (interrupted) {
+        clearInterruptedFlag(activateMsg.sessionId);
       }
+      var busy = isSessionBusy(activateMsg.sessionId);
+      var busyOwner = busy ? getBusyOwner(activateMsg.sessionId) : undefined;
+      sendTo(clientId, {
+        type: "session:history",
+        projectSlug: activateMsg.projectSlug,
+        sessionId: activateMsg.sessionId,
+        messages: historyResult.messages,
+        title: title,
+        interrupted: interrupted || undefined,
+        busy: busy || undefined,
+        busyOwner: busyOwner,
+        totalMessages: historyResult.totalMessages,
+        hasMore: historyResult.hasMore,
+      });
+    }).catch(function (err) {
+      log.session("Error sending session history: %O", err);
+      sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
+    });
+
+    void Promise.all([
+      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+    ]).then(function (results) {
       try {
-        var usage = results[2];
+        var usage = results[0];
         if (usage) {
           sendTo(clientId, {
             type: "chat:context_usage",
@@ -162,7 +157,7 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
         log.session("Error sending context usage: %O", err);
       }
       try {
-        var breakdown = results[3];
+        var breakdown = results[1];
         if (breakdown) {
           sendTo(clientId, {
             type: "chat:context_breakdown",

package/server/src/project/session.ts

@@ -458,45 +458,111 @@ export async function getSessionTitle(projectSlug: string, sessionId: string): P
 }
 
 var historyCache = new Map<string, { messages: HistoryMessage[]; time: number }>();
-var HISTORY_CACHE_TTL = 30000;
+var HISTORY_CACHE_TTL = 60000;
 var INITIAL_MESSAGE_COUNT = 100;
+var TAIL_READ_BYTES = 2 * 1024 * 1024;
 
-export async function loadSessionHistory(projectSlug: string, sessionId: string): Promise<{ messages: HistoryMessage[]; totalMessages: number; hasMore: boolean }> {
+function getSessionFilePath(projectSlug: string, sessionId: string): string | null {
   var projectPath = getProjectPath(projectSlug);
-  var options = projectPath ? { dir: projectPath } : undefined;
+  if (!projectPath) return null;
+  var hash = projectPathToHash(projectPath);
+  var filePath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+  return existsSync(filePath) ? filePath : null;
+}
+
+function readTailLines(filePath: string, maxBytes: number): { lines: string[]; isPartial: boolean; fileSize: number } {
+  var { openSync, readSync, fstatSync, closeSync } = require("node:fs") as typeof import("node:fs");
+  var fd = openSync(filePath, "r");
+  var stat = fstatSync(fd);
+  var readStart = Math.max(0, stat.size - maxBytes);
+  var buf = Buffer.alloc(stat.size - readStart);
+  readSync(fd, buf, 0, buf.length, readStart);
+  closeSync(fd);
+  var text = buf.toString("utf-8");
+  if (readStart > 0) {
+    var firstNewline = text.indexOf("\n");
+    if (firstNewline >= 0) text = text.slice(firstNewline + 1);
+  }
+  var lines = text.split("\n").filter(function (l) { return l.length > 0; });
+  return { lines, isPartial: readStart > 0, fileSize: stat.size };
+}
 
+function parseJsonlLines(lines: string[]): SessionMessage[] {
+  var results: SessionMessage[] = [];
+  for (var i = 0; i < lines.length; i++) {
+    try {
+      var parsed = JSON.parse(lines[i]);
+      if (parsed.type === "user" || parsed.type === "assistant" || parsed.type === "system") {
+        results.push(parsed as SessionMessage);
+      }
+    } catch {}
+  }
+  return results;
+}
+
+export async function loadSessionHistory(projectSlug: string, sessionId: string): Promise<{ messages: HistoryMessage[]; totalMessages: number; hasMore: boolean }> {
   try {
     var t0 = Date.now();
     var cached = historyCache.get(sessionId);
-    var allMessages: HistoryMessage[];
-
     if (cached && Date.now() - cached.time < HISTORY_CACHE_TTL) {
-      allMessages = cached.messages;
-    } else {
-      var rawMessages = await getSessionMessages(sessionId, options);
-      allMessages = convertSessionMessages(rawMessages);
-      historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+      var tail = cached.messages.length > INITIAL_MESSAGE_COUNT
+        ? cached.messages.slice(cached.messages.length - INITIAL_MESSAGE_COUNT)
+        : cached.messages;
+      log.session("loadSessionHistory %s: %dms (cached, %d total)", sessionId.slice(0, 8), Date.now() - t0, cached.messages.length);
+      return { messages: tail, totalMessages: cached.messages.length, hasMore: cached.messages.length > INITIAL_MESSAGE_COUNT };
     }
 
-    log.session("loadSessionHistory %s: %dms, %d total messages", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
+    var filePath = getSessionFilePath(projectSlug, sessionId);
+    if (filePath) {
+      var tailData = readTailLines(filePath, TAIL_READ_BYTES);
+      var tailRaw = parseJsonlLines(tailData.lines);
+      var tailMessages = convertSessionMessages(tailRaw);
+      var hasMore = tailData.isPartial;
+
+      log.session("loadSessionHistory %s: %dms (tail read, %d msgs, partial=%s)", sessionId.slice(0, 8), Date.now() - t0, tailMessages.length, hasMore);
+
+      if (!hasMore) {
+        historyCache.set(sessionId, { messages: tailMessages, time: Date.now() });
+      }
+
+      var initialSlice = tailMessages.length > INITIAL_MESSAGE_COUNT
+        ? tailMessages.slice(tailMessages.length - INITIAL_MESSAGE_COUNT)
+        : tailMessages;
+
+      return { messages: initialSlice, totalMessages: tailMessages.length, hasMore: hasMore };
+    }
 
-    var tail = allMessages.length > INITIAL_MESSAGE_COUNT
+    var projectPath = getProjectPath(projectSlug);
+    var options = projectPath ? { dir: projectPath } : undefined;
+    var rawMessages = await getSessionMessages(sessionId, options);
+    var allMessages = convertSessionMessages(rawMessages);
+    historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+    log.session("loadSessionHistory %s: %dms (full SDK, %d msgs)", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
+    var tailSlice = allMessages.length > INITIAL_MESSAGE_COUNT
       ? allMessages.slice(allMessages.length - INITIAL_MESSAGE_COUNT)
       : allMessages;
-
-    return {
-      messages: tail,
-      totalMessages: allMessages.length,
-      hasMore: allMessages.length > INITIAL_MESSAGE_COUNT,
-    };
+    return { messages: tailSlice, totalMessages: allMessages.length, hasMore: allMessages.length > INITIAL_MESSAGE_COUNT };
   } catch (err) {
     log.session("Failed to load session history: %O", err);
     return { messages: [], totalMessages: 0, hasMore: false };
   }
 }
 
-export function getSessionHistoryPage(sessionId: string, beforeIndex: number, limit: number): { messages: HistoryMessage[]; hasMore: boolean } {
+export async function getSessionHistoryPage(sessionId: string, beforeIndex: number, limit: number, projectSlug?: string): Promise<{ messages: HistoryMessage[]; hasMore: boolean }> {
   var cached = historyCache.get(sessionId);
+  if (!cached && projectSlug) {
+    var projectPath = getProjectPath(projectSlug);
+    var options = projectPath ? { dir: projectPath } : undefined;
+    try {
+      var rawMessages = await getSessionMessages(sessionId, options);
+      var allMessages = convertSessionMessages(rawMessages);
+      historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+      cached = { messages: allMessages, time: Date.now() };
+      log.session("getSessionHistoryPage: full load for %s, %d messages", sessionId.slice(0, 8), allMessages.length);
+    } catch {
+      return { messages: [], hasMore: false };
+    }
+  }
   if (!cached) return { messages: [], hasMore: false };
 
   var endIdx = Math.max(0, beforeIndex);