@cryptiklemur/lattice 5.4.2 → 5.5.0

package/dist/server/handlers/fs.js

@@ -13,6 +13,9 @@ export function setActiveProject(clientId, projectSlug) {
 export function clearActiveProject(clientId) {
     activeProjectByClient.delete(clientId);
 }
+export function getActiveProjectForClient(clientId) {
+    return activeProjectByClient.get(clientId);
+}
 registerHandler("fs", function (clientId, message) {
     if (message.type === "fs:list") {
         var listMsg = message;

package/dist/server/handlers/session.js

@@ -1,7 +1,7 @@
 import { registerHandler } from "../ws/router.js";
-import { sendTo } from "../ws/broadcast.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
 import { loadConfig } from "../config.js";
-import { createSession, deleteSession, findProjectSlugForSession, getSessionPreview, getSessionTitle, getSessionUsage, listSessions, invalidateSessionCache, invalidateHistoryCache, getSessionHistoryPage, loadSessionHistory, renameSession, getSessionFileSizeBytes, } from "../project/session.js";
+import { createSession, deleteSession, findProjectSlugForSession, getSessionPreview, getSessionTitle, getSessionUsage, listSessions, invalidateSessionCache, invalidateHistoryCache, getSessionHistoryPage, loadSessionHistory, renameSession, getSessionFileSizeBytes, updateSessionInIndex, removeSessionFromIndex, } from "../project/session.js";
 import { getContextBreakdown } from "../project/context-breakdown.js";
 import { setActiveSession, getActiveSession } from "./chat.js";
 import { setActiveProject } from "./fs.js";
@@ -71,7 +71,15 @@ registerHandler("session", function (clientId, message) {
     if (message.type === "session:create") {
         var createMsg = message;
         var session = createSession(createMsg.projectSlug);
+        updateSessionInIndex(createMsg.projectSlug, session);
         sendTo(clientId, { type: "session:created", session });
+        broadcast({
+            type: "session:list",
+            projectSlug: createMsg.projectSlug,
+            sessions: [session],
+            totalCount: undefined,
+            offset: 0,
+        });
         return;
     }
     if (message.type === "session:activate") {
@@ -160,7 +168,7 @@ registerHandler("session", function (clientId, message) {
             void renameSession(projectSlug, renameMsg.sessionId, renameMsg.title).then(function () {
                 invalidateSessionCache(projectSlug);
                 void listSessions(projectSlug, { limit: 40 }).then(function (result) {
-                    sendTo(clientId, {
+                    broadcast({
                         type: "session:list",
                         projectSlug,
                         sessions: result.sessions,
@@ -179,9 +187,9 @@ registerHandler("session", function (clientId, message) {
                 return;
             }
             void deleteSession(deleteProjectSlug, deleteMsg.sessionId).then(function () {
-                invalidateSessionCache(deleteProjectSlug);
+                removeSessionFromIndex(deleteProjectSlug, deleteMsg.sessionId);
                 void listSessions(deleteProjectSlug, { limit: 40 }).then(function (result) {
-                    sendTo(clientId, {
+                    broadcast({
                         type: "session:list",
                         projectSlug: deleteProjectSlug,
                         sessions: result.sessions,

package/dist/server/project/sdk-bridge.js

@@ -671,7 +671,6 @@ export function startChatStream(options) {
     persistStreamState();
     broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
     void (async function () {
-        var retried = false;
         try {
             await stream.initializationResult();
         }
@@ -689,27 +688,8 @@ export function startChatStream(options) {
             if (errMsg.includes("aborted") || errMsg.includes("AbortError")) {
                 log.chat("Session %s stream aborted", sessionId);
             }
-            else if (errMsg.includes("Sent before connected") && !retried) {
-                retried = true;
-                log.chat("Session %s SDK WebSocket race condition, retrying after delay...", sessionId);
-                await new Promise(function (r) { setTimeout(r, 500); });
-                try {
-                    var retryMq = createMessageQueue();
-                    var retryStream = query({ prompt: retryMq, options: queryOptions });
-                    retryMq.push(firstMsg);
-                    sessionStream.queryInstance = retryStream;
-                    sessionStream.messageQueue = retryMq;
-                    for await (var retryMsg of retryStream) {
-                        processMessage(sessionStream, retryMsg);
-                    }
-                }
-                catch (retryErr) {
-                    var retryErrMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                    if (!retryErrMsg.includes("aborted") && !retryErrMsg.includes("AbortError")) {
-                        console.error("[lattice] SDK stream retry error: " + retryErrMsg);
-                        sendTo(sessionStream.clientId, { type: "chat:error", message: retryErrMsg });
-                    }
-                }
+            else if (errMsg.includes("Sent before connected")) {
+                log.chat("Session %s SDK WebSocket race condition: %s", sessionId, errMsg);
             }
             else {
                 console.error("[lattice] SDK stream error: " + errMsg);

package/dist/server/project/session.js

@@ -1,10 +1,10 @@
 import { listSessions as sdkListSessions, getSessionInfo, getSessionMessages, renameSession as sdkRenameSession, } from "@anthropic-ai/claude-agent-sdk";
-import { existsSync, unlinkSync, readFileSync, statSync } from "node:fs";
+import { existsSync, unlinkSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { loadConfig } from "../config.js";
+import { loadConfig, getLatticeHome } from "../config.js";
 import { log } from "../logger.js";
 function getProjectPath(projectSlug) {
     var config = loadConfig();
@@ -428,7 +428,81 @@ export async function getSessionPreview(projectSlug, sessionId) {
     }
 }
 var sessionListCache = new Map();
-var SESSION_CACHE_TTL = 5000;
+var SESSION_CACHE_TTL = 60000;
+var RECONCILE_INTERVAL = 5 * 60 * 1000;
+var lastReconcile = new Map();
+function getIndexPath() {
+    return join(getLatticeHome(), "session-index.json");
+}
+function loadSessionIndex() {
+    var indexPath = getIndexPath();
+    if (!existsSync(indexPath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(indexPath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveSessionIndex(index) {
+    try {
+        writeFileSync(getIndexPath(), JSON.stringify(index), "utf-8");
+    }
+    catch (err) {
+        log.session("Failed to save session index: %O", err);
+    }
+}
+export function updateSessionInIndex(projectSlug, session) {
+    var index = loadSessionIndex();
+    var sessions = index[projectSlug] || [];
+    var existing = -1;
+    for (var i = 0; i < sessions.length; i++) {
+        if (sessions[i].id === session.id) {
+            existing = i;
+            break;
+        }
+    }
+    if (existing >= 0) {
+        sessions[existing] = session;
+    }
+    else {
+        sessions.push(session);
+    }
+    sessions.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
+    index[projectSlug] = sessions;
+    saveSessionIndex(index);
+    sessionListCache.set(projectSlug, { sessions, time: Date.now() });
+}
+export function removeSessionFromIndex(projectSlug, sessionId) {
+    var index = loadSessionIndex();
+    var sessions = index[projectSlug] || [];
+    index[projectSlug] = sessions.filter(function (s) { return s.id !== sessionId; });
+    saveSessionIndex(index);
+    sessionListCache.set(projectSlug, { sessions: index[projectSlug], time: Date.now() });
+}
+async function reconcileWithSDK(projectSlug) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath)
+        return [];
+    var sdkT0 = Date.now();
+    var sdkSessions = await sdkListSessions({ dir: projectPath });
+    log.session("sdkListSessions for %s: %dms (%d sessions)", projectSlug, Date.now() - sdkT0, sdkSessions.length);
+    var summaries = sdkSessions.map(function (s) { return mapSDKSession(s, projectSlug); });
+    summaries.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
+    var index = loadSessionIndex();
+    index[projectSlug] = summaries;
+    saveSessionIndex(index);
+    sessionListCache.set(projectSlug, { sessions: summaries, time: Date.now() });
+    lastReconcile.set(projectSlug, Date.now());
+    return summaries;
+}
+function needsReconcile(projectSlug) {
+    var last = lastReconcile.get(projectSlug);
+    if (!last)
+        return true;
+    return Date.now() - last > RECONCILE_INTERVAL;
+}
 export async function listSessions(projectSlug, options) {
     var projectPath = getProjectPath(projectSlug);
     if (!projectPath) {
@@ -441,15 +515,22 @@ export async function listSessions(projectSlug, options) {
         var sliced = limit > 0 ? cached.sessions.slice(offset, offset + limit) : cached.sessions;
         return { sessions: sliced, totalCount: cached.sessions.length };
     }
+    var index = loadSessionIndex();
+    var indexed = index[projectSlug];
+    if (indexed && indexed.length > 0) {
+        sessionListCache.set(projectSlug, { sessions: indexed, time: Date.now() });
+        if (needsReconcile(projectSlug)) {
+            reconcileWithSDK(projectSlug).catch(function (err) {
+                log.session("Background reconcile failed: %O", err);
+            });
+        }
+        var offset3 = options?.offset ?? 0;
+        var limit3 = options?.limit ?? 0;
+        var sliced3 = limit3 > 0 ? indexed.slice(offset3, offset3 + limit3) : indexed;
+        return { sessions: sliced3, totalCount: indexed.length };
+    }
     try {
-        var sdkT0 = Date.now();
-        var sdkSessions = await sdkListSessions({ dir: projectPath });
-        log.session("sdkListSessions for %s: %dms (%d sessions)", projectSlug, Date.now() - sdkT0, sdkSessions.length);
-        var summaries = sdkSessions.map(function (s) {
-            return mapSDKSession(s, projectSlug);
-        });
-        summaries.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
-        sessionListCache.set(projectSlug, { sessions: summaries, time: Date.now() });
+        var summaries = await reconcileWithSDK(projectSlug);
         var offset2 = options?.offset ?? 0;
         var limit2 = options?.limit ?? 0;
         var sliced2 = limit2 > 0 ? summaries.slice(offset2, offset2 + limit2) : summaries;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "5.4.2",
+  "version": "5.5.0",
   "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>",