@cryptiklemur/lattice 5.5.0 → 5.6.0

package/dist/server/mesh/connector.js

@@ -18,6 +18,77 @@ var CIRCUIT_BREAKER_THRESHOLD = 5;
 var CIRCUIT_BREAKER_COOLDOWN = 60000;
 var circuitBreakers = new Map();
 var RECONNECT_INTERVAL_MS = 15000;
+var HEALTH_CHECK_INTERVAL_MS = 30000;
+var HEALTH_MISS_THRESHOLD = 3;
+var healthStates = new Map();
+export function getPeerHealth(nodeId) {
+    var state = healthStates.get(nodeId);
+    if (!state)
+        return undefined;
+    return { latencyMs: state.latencyMs, healthy: state.healthy };
+}
+export function getAllPeerHealth() {
+    var result = new Map();
+    for (var [nodeId, state] of healthStates) {
+        result.set(nodeId, { latencyMs: state.latencyMs, healthy: state.healthy });
+    }
+    return result;
+}
+function startHealthCheck(conn) {
+    var state = healthStates.get(conn.nodeId);
+    if (state && state.pingTimer)
+        return;
+    var healthState = {
+        lastPongAt: Date.now(),
+        latencyMs: 0,
+        missedPongs: 0,
+        healthy: true,
+        pingTimer: null,
+    };
+    healthStates.set(conn.nodeId, healthState);
+    var lastPingSentAt = 0;
+    healthState.pingTimer = setInterval(function () {
+        if (conn.dead || !isWebSocketOpen(conn.ws)) {
+            stopHealthCheck(conn.nodeId);
+            return;
+        }
+        if (lastPingSentAt > 0 && healthState.lastPongAt < lastPingSentAt) {
+            healthState.missedPongs++;
+            if (healthState.missedPongs >= HEALTH_MISS_THRESHOLD && healthState.healthy) {
+                healthState.healthy = false;
+                log.mesh("Health check: peer %s marked unhealthy (%d missed pongs)", conn.nodeId.slice(0, 8), healthState.missedPongs);
+            }
+        }
+        lastPingSentAt = Date.now();
+        try {
+            conn.ws.send(JSON.stringify({ type: "mesh:ping", timestamp: lastPingSentAt }));
+        }
+        catch {
+            healthState.missedPongs++;
+        }
+    }, HEALTH_CHECK_INTERVAL_MS);
+    healthState.pingTimer.unref?.();
+}
+function stopHealthCheck(nodeId) {
+    var state = healthStates.get(nodeId);
+    if (state && state.pingTimer) {
+        clearInterval(state.pingTimer);
+        state.pingTimer = null;
+    }
+    healthStates.delete(nodeId);
+}
+function handlePong(nodeId, timestamp) {
+    var state = healthStates.get(nodeId);
+    if (!state)
+        return;
+    state.lastPongAt = Date.now();
+    state.latencyMs = Date.now() - timestamp;
+    state.missedPongs = 0;
+    if (!state.healthy) {
+        state.healthy = true;
+        log.mesh("Health check: peer %s recovered (latency: %dms)", nodeId.slice(0, 8), state.latencyMs);
+    }
+}
 export function startMeshConnections() {
     reconcilePeers();
     setInterval(reconcilePeers, RECONNECT_INTERVAL_MS);
@@ -45,12 +116,13 @@ function reconcilePeers() {
     }
 }
 export function stopMeshConnections() {
-    for (var [, conn] of connections) {
+    for (var [nodeId, conn] of connections) {
         conn.dead = true;
         if (conn.retryTimer !== null) {
             clearTimeout(conn.retryTimer);
             conn.retryTimer = null;
         }
+        stopHealthCheck(nodeId);
         conn.ws.close();
     }
     connections.clear();
@@ -142,6 +214,17 @@ function openConnection(conn, url) {
                 if (msg.projects.length > 0) {
                     lastKnownProjects.set(conn.nodeId, msg.projects);
                 }
+                startHealthCheck(conn);
+            }
+            else if (msg.type === "mesh:ping") {
+                var pingMsg = msg;
+                conn.ws.send(JSON.stringify({ type: "mesh:pong", timestamp: pingMsg.timestamp }));
+                return;
+            }
+            else if (msg.type === "mesh:pong") {
+                var pongMsg = msg;
+                handlePong(conn.nodeId, pongMsg.timestamp);
+                return;
             }
             else if (msg.type === "mesh:session_sync") {
                 handleSessionSync(conn.nodeId, msg);
@@ -264,6 +347,7 @@ export function disconnectPeer(nodeId) {
         existing.ws.close();
         connections.delete(nodeId);
     }
+    stopHealthCheck(nodeId);
     circuitBreakers.delete(nodeId);
 }
 export function reconnectPeer(nodeId) {

package/dist/server/project/file-browser.js

@@ -1,4 +1,4 @@
-import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { readdir, readFile as fsReadFile, stat, writeFile as fsWriteFile } from "node:fs/promises";
 import { join, resolve, relative } from "node:path";
 var MAX_FILE_SIZE = 512 * 1024;
 export function validatePath(projectPath, relativePath) {
@@ -9,7 +9,7 @@ export function validatePath(projectPath, relativePath) {
     }
     return resolved;
 }
-export function listDirectory(projectPath, relativePath) {
+export async function listDirectory(projectPath, relativePath) {
     var fullPath = validatePath(projectPath, relativePath);
     if (!fullPath) {
         return [];
@@ -17,7 +17,7 @@ export function listDirectory(projectPath, relativePath) {
     var entries = [];
     var names;
     try {
-        names = readdirSync(fullPath);
+        names = await readdir(fullPath);
     }
     catch {
         return [];
@@ -29,14 +29,14 @@ export function listDirectory(projectPath, relativePath) {
         }
         var entryFull = join(fullPath, name);
         try {
-            var stat = statSync(entryFull);
+            var entryStat = await stat(entryFull);
             var entryRelative = relative(projectPath, entryFull);
             entries.push({
                 name: name,
                 path: entryRelative,
-                isDirectory: stat.isDirectory(),
-                size: stat.isDirectory() ? 0 : stat.size,
-                modifiedAt: stat.mtimeMs,
+                isDirectory: entryStat.isDirectory(),
+                size: entryStat.isDirectory() ? 0 : entryStat.size,
+                modifiedAt: entryStat.mtimeMs,
             });
         }
         catch {
@@ -52,24 +52,24 @@ export function listDirectory(projectPath, relativePath) {
     });
     return entries;
 }
-export function readFile(projectPath, relativePath) {
+export async function readFile(projectPath, relativePath) {
     var fullPath = validatePath(projectPath, relativePath);
     if (!fullPath) {
         return null;
     }
-    var stat;
+    var fileStat;
     try {
-        stat = statSync(fullPath);
+        fileStat = await stat(fullPath);
     }
     catch {
         return null;
     }
-    if (stat.size > MAX_FILE_SIZE) {
+    if (fileStat.size > MAX_FILE_SIZE) {
         return null;
     }
     var buf;
     try {
-        buf = readFileSync(fullPath);
+        buf = await fsReadFile(fullPath);
     }
     catch {
         return null;
@@ -82,13 +82,13 @@ export function readFile(projectPath, relativePath) {
     }
     return buf.toString("utf-8");
 }
-export function writeFile(projectPath, relativePath, content) {
+export async function writeFile(projectPath, relativePath, content) {
     var fullPath = validatePath(projectPath, relativePath);
     if (!fullPath) {
         return false;
     }
     try {
-        writeFileSync(fullPath, content, "utf-8");
+        await fsWriteFile(fullPath, content, "utf-8");
         return true;
     }
     catch {

package/dist/server/project/session.js

@@ -1,5 +1,5 @@
 import { listSessions as sdkListSessions, getSessionInfo, getSessionMessages, renameSession as sdkRenameSession, } from "@anthropic-ai/claude-agent-sdk";
-import { existsSync, unlinkSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, unlinkSync, readFileSync, writeFileSync } from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -55,7 +55,9 @@ export function loadPricing() {
             };
             pricingCache[key] = pricingCache[modelId];
         }
-    }).catch(function () { });
+    }).catch(function (err) {
+        log.session("Failed to load pricing data: %O", err);
+    });
 }
 loadPricing();
 export function getPricing(model) {
@@ -595,12 +597,13 @@ function getSessionFilePath(projectSlug, sessionId) {
     var filePath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
     return existsSync(filePath) ? filePath : null;
 }
-export function getSessionFileSizeBytes(projectSlug, sessionId) {
+export async function getSessionFileSizeBytes(projectSlug, sessionId) {
     var filePath = getSessionFilePath(projectSlug, sessionId);
     if (!filePath)
         return null;
     try {
-        return statSync(filePath).size;
+        var fileStat = await fsPromises.stat(filePath);
+        return fileStat.size;
     }
     catch {
         return null;

package/dist/server/ws/broadcast.js

@@ -1,5 +1,7 @@
 import { log } from "../logger.js";
 var clients = new Map();
+var clientAlive = new Map();
+var clientProjects = new Map();
 var virtualSendHandlers = new Map();
 export function registerVirtualClient(id, handler) {
     virtualSendHandlers.set(id, handler);
@@ -9,9 +11,34 @@ export function removeVirtualClient(id) {
 }
 export function addClient(id, ws) {
     clients.set(id, ws);
+    clientAlive.set(id, true);
 }
 export function removeClient(id) {
     clients.delete(id);
+    clientAlive.delete(id);
+    clientProjects.delete(id);
+}
+export function markClientAlive(id) {
+    clientAlive.set(id, true);
+}
+export function subscribeClientToProject(clientId, projectSlug) {
+    var projects = clientProjects.get(clientId);
+    if (!projects) {
+        projects = new Set();
+        clientProjects.set(clientId, projects);
+    }
+    projects.add(projectSlug);
+}
+export function broadcastToProject(projectSlug, message, excludeId) {
+    var text = JSON.stringify(message);
+    for (var [id, ws] of clients) {
+        if (id !== excludeId && ws.readyState === ws.OPEN) {
+            var projects = clientProjects.get(id);
+            if (projects && projects.has(projectSlug)) {
+                ws.send(text);
+            }
+        }
+    }
 }
 export function broadcast(message, excludeId) {
     var text = JSON.stringify(message);
@@ -47,4 +74,37 @@ export function closeAllClients() {
         ws.close();
     }
     clients.clear();
+    clientAlive.clear();
+    clientProjects.clear();
+}
+var HEARTBEAT_INTERVAL_MS = 30000;
+var heartbeatTimer = null;
+export function startHeartbeat(onDead) {
+    if (heartbeatTimer)
+        return;
+    heartbeatTimer = setInterval(function () {
+        var dead = [];
+        for (var [id, ws] of clients) {
+            if (!clientAlive.get(id)) {
+                dead.push([id, ws]);
+                continue;
+            }
+            clientAlive.set(id, false);
+            if (ws.readyState === ws.OPEN) {
+                ws.ping();
+            }
+        }
+        for (var i = 0; i < dead.length; i++) {
+            log.ws("Heartbeat: client %s unresponsive, terminating", dead[i][0].slice(0, 8));
+            onDead(dead[i][0], dead[i][1]);
+            dead[i][1].terminate();
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+    heartbeatTimer.unref();
+}
+export function stopHeartbeat() {
+    if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+    }
 }

package/package.json

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