@cryptiklemur/lattice 1.14.1 → 1.15.0

package/client/src/components/workspace/TaskEditModal.tsx

@@ -1,5 +1,6 @@
-import { useState } from "react";
+import { useState, useRef, useCallback } from "react";
 import { X } from "lucide-react";
+import { useFocusTrap } from "../../hooks/useFocusTrap";
 import cronstrue from "cronstrue";
 import type { ScheduledTask } from "@lattice/shared";
 
@@ -25,6 +26,10 @@ export function TaskEditModal(props: TaskEditModalProps) {
   var [prompt, setPrompt] = useState(task ? task.prompt : "");
   var [cron, setCron] = useState(task ? task.cron : "0 9 * * 1-5");
 
+  var modalRef = useRef<HTMLDivElement>(null);
+  var stableOnClose = useCallback(function () { onClose(); }, [onClose]);
+  useFocusTrap(modalRef, stableOnClose);
+
   var cronPreview = getCronPreview(cron);
   var cronValid = cronPreview !== "Invalid cron expression" && cronPreview !== "";
 
@@ -40,12 +45,12 @@ export function TaskEditModal(props: TaskEditModalProps) {
 
   return (
     <div
+      ref={modalRef}
       className="fixed inset-0 z-[9999] flex items-center justify-center bg-black/50 backdrop-blur-sm"
       onClick={handleBackdrop}
       role="dialog"
       aria-modal="true"
       aria-label={task ? "Edit Task" : "New Scheduled Task"}
-      onKeyDown={function (e) { if (e.key === "Escape") onClose(); }}
     >
       <div className="bg-base-200 border border-base-content/15 rounded-2xl shadow-2xl w-full max-w-md mx-4">
         <div className="flex items-center justify-between px-5 py-4 border-b border-base-content/15">

package/client/src/hooks/useFocusTrap.ts

@@ -0,0 +1,72 @@
+import { useEffect, useRef } from "react";
+
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])",
+].join(", ");
+
+export function useFocusTrap(
+  containerRef: React.RefObject<HTMLElement | null>,
+  onClose: () => void,
+  active: boolean = true,
+): void {
+  var previouslyFocusedRef = useRef<HTMLElement | null>(null);
+
+  useEffect(function () {
+    if (!active) return;
+
+    var container = containerRef.current;
+    if (!container) return;
+
+    previouslyFocusedRef.current = document.activeElement as HTMLElement | null;
+
+    var focusable = container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
+    if (focusable.length > 0) {
+      focusable[0].focus();
+    }
+
+    function handleKeyDown(e: KeyboardEvent) {
+      if (e.key === "Escape") {
+        onClose();
+        return;
+      }
+
+      if (e.key !== "Tab") return;
+
+      var currentContainer = containerRef.current;
+      if (!currentContainer) return;
+
+      var elements = currentContainer.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
+      if (elements.length === 0) return;
+
+      var first = elements[0];
+      var last = elements[elements.length - 1];
+
+      if (e.shiftKey) {
+        if (document.activeElement === first) {
+          e.preventDefault();
+          last.focus();
+        }
+      } else {
+        if (document.activeElement === last) {
+          e.preventDefault();
+          first.focus();
+        }
+      }
+    }
+
+    var el = container;
+    el.addEventListener("keydown", handleKeyDown);
+
+    return function () {
+      el.removeEventListener("keydown", handleKeyDown);
+      if (previouslyFocusedRef.current && typeof previouslyFocusedRef.current.focus === "function") {
+        previouslyFocusedRef.current.focus();
+      }
+    };
+  }, [containerRef, onClose, active]);
+}

package/client/src/hooks/useWebSocket.ts

@@ -8,6 +8,7 @@ export interface WebSocketContextValue {
   send: (msg: ClientMessage) => void;
   subscribe: (type: string, callback: (msg: ServerMessage) => void) => void;
   unsubscribe: (type: string, callback: (msg: ServerMessage) => void) => void;
+  reconnectNow: () => void;
 }
 
 export var WebSocketContext = createContext<WebSocketContextValue | null>(null);

package/client/src/providers/WebSocketProvider.tsx

@@ -80,7 +80,8 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
             cb(msg);
           });
         }
-      } catch {
+      } catch (err) {
+        console.warn("[lattice] Failed to parse WebSocket message:", err);
       }
     };
 
@@ -91,7 +92,7 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
       setStatus("disconnected");
       wsRef.current = null;
       if (hasConnectedRef.current) {
-        showToast("Disconnected from daemon. Reconnecting...", "warning");
+        showToast("Disconnected from daemon. Reconnecting automatically...", "warning");
         sendNotification("Lattice", "Lost connection to daemon", "connection");
       }
       scheduleReconnect();
@@ -113,6 +114,19 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
     }, delay);
   }
 
+  function reconnectNow() {
+    if (retryTimerRef.current !== null) {
+      clearTimeout(retryTimerRef.current);
+      retryTimerRef.current = null;
+    }
+    backoffRef.current = 1000;
+    if (wsRef.current) {
+      wsRef.current.close();
+      wsRef.current = null;
+    }
+    connect();
+  }
+
   function send(msg: ClientMessage) {
     var ws = wsRef.current;
     if (ws && ws.readyState === WebSocket.OPEN) {
@@ -157,7 +171,7 @@ export function WebSocketProvider(props: WebSocketProviderProps) {
   }, []);
 
   return (
-    <WebSocketContext.Provider value={{ status, send, subscribe, unsubscribe }}>
+    <WebSocketContext.Provider value={{ status, send, subscribe, unsubscribe, reconnectNow }}>
       {props.children}
     </WebSocketContext.Provider>
   );

package/client/src/router.tsx

@@ -1,6 +1,7 @@
 import { createRouter, createRootRoute, createRoute, createMemoryHistory } from "@tanstack/react-router";
 import { Outlet } from "@tanstack/react-router";
-import { useState, useEffect, useRef } from "react";
+import { useState, useEffect, useRef, useCallback } from "react";
+import { useFocusTrap } from "./hooks/useFocusTrap";
 import { Sidebar } from "./components/sidebar/Sidebar";
 import { WorkspaceView } from "./components/workspace/WorkspaceView";
 import { SetupWizard } from "./components/setup/SetupWizard";
@@ -299,6 +300,9 @@ function RemoveProjectConfirm() {
   var sidebar = useSidebar();
   var ws = useWebSocket();
   var slug = sidebar.confirmRemoveSlug;
+  var removeModalRef = useRef<HTMLDivElement>(null);
+  var stableCloseRemove = useCallback(function () { sidebar.closeConfirmRemove(); }, [sidebar.closeConfirmRemove]);
+  useFocusTrap(removeModalRef, stableCloseRemove, !!slug);
 
   if (!slug) return null;
 
@@ -311,17 +315,8 @@ function RemoveProjectConfirm() {
     }
   })();
 
-  useEffect(function () {
-    if (!slug) return;
-    function handleKeyDown(e: KeyboardEvent) {
-      if (e.key === "Escape") sidebar.closeConfirmRemove();
-    }
-    document.addEventListener("keydown", handleKeyDown);
-    return function () { document.removeEventListener("keydown", handleKeyDown); };
-  }, [slug]);
-
   return (
-    <div className="fixed inset-0 z-[9999] flex items-center justify-center" role="dialog" aria-modal="true" aria-label="Remove Project">
+    <div ref={removeModalRef} className="fixed inset-0 z-[9999] flex items-center justify-center" role="dialog" aria-modal="true" aria-label="Remove Project">
       <div className="absolute inset-0 bg-black/50" onClick={sidebar.closeConfirmRemove} />
       <div className="relative bg-base-200 border border-base-content/15 rounded-2xl shadow-2xl w-full max-w-sm mx-4 overflow-hidden">
         <div className="px-5 py-4 border-b border-base-content/15">

package/package.json

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

package/server/package.json

@@ -11,11 +11,13 @@
     "@anthropic-ai/claude-agent-sdk": "^0.2.79",
     "@lattice/shared": "workspace:*",
     "bonjour-service": "^1.3.0",
+    "debug": "^4.4.3",
     "js-tiktoken": "^1.0.21",
     "node-pty": "^1.1.0",
     "qrcode": "^1.5.4"
   },
   "devDependencies": {
+    "@types/debug": "^4.1.13",
     "@types/qrcode": "^1.5.6",
     "bun-types": "latest"
   }

package/server/src/auth/passphrase.ts

@@ -1,6 +1,9 @@
 import { scryptSync, randomBytes, timingSafeEqual } from "node:crypto";
 
-var activeSessions = new Set<string>();
+var TOKEN_TTL = 86400000;
+var CLEANUP_INTERVAL = 600000;
+
+var activeSessions = new Map<string, number>();
 
 export function hashPassphrase(passphrase: string): string {
   var salt = randomBytes(16).toString("hex");
@@ -32,7 +35,7 @@ export function generateSessionToken(): string {
 }
 
 export function addSession(token: string): void {
-  activeSessions.add(token);
+  activeSessions.set(token, Date.now());
 }
 
 export function removeSession(token: string): void {
@@ -40,9 +43,26 @@ export function removeSession(token: string): void {
 }
 
 export function isValidSession(token: string): boolean {
-  return activeSessions.has(token);
+  var createdAt = activeSessions.get(token);
+  if (createdAt === undefined) {
+    return false;
+  }
+  if (Date.now() - createdAt > TOKEN_TTL) {
+    activeSessions.delete(token);
+    return false;
+  }
+  return true;
 }
 
 export function clearSessions(): void {
   activeSessions.clear();
 }
+
+setInterval(function () {
+  var now = Date.now();
+  activeSessions.forEach(function (createdAt, token) {
+    if (now - createdAt > TOKEN_TTL) {
+      activeSessions.delete(token);
+    }
+  });
+}, CLEANUP_INTERVAL);

package/server/src/daemon.ts

@@ -12,11 +12,14 @@ import { handleProxyRequest, handleProxyResponse } from "./mesh/proxy";
 import { verifyPassphrase, generateSessionToken, addSession, isValidSession } from "./auth/passphrase";
 import { ensureCerts } from "./tls";
 import type { ClientMessage, MeshMessage } from "@lattice/shared";
+import { log } from "./logger";
 import "./handlers/session";
 import "./handlers/chat";
 import "./handlers/attachment";
 import { loadInterruptedSessions, unwatchSessionLock, cleanupClientPermissions } from "./project/sdk-bridge";
 import { clearActiveSession, getActiveSession } from "./handlers/chat";
+import { clearActiveProject } from "./handlers/fs";
+import { clearClientRemoteNode } from "./ws/router";
 import "./handlers/fs";
 import "./handlers/terminal";
 import "./handlers/settings";
@@ -38,6 +41,10 @@ interface WsData {
   id: string;
 }
 
+var RATE_LIMIT_WINDOW = 10000;
+var RATE_LIMIT_MAX = 100;
+var clientRateLimits = new Map<string, { count: number; windowStart: number }>();
+
 function parseCookies(cookieHeader: string): Map<string, string> {
   var map = new Map<string, string>();
   var parts = cookieHeader.split(";");
@@ -188,8 +195,8 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
   }
   var identity = loadOrCreateIdentity();
 
-  console.log(`[lattice] Node: ${config.name} (${identity.id})`);
-  console.log(`[lattice] Home: ${getLatticeHome()}`);
+  log.server("Node: %s (%s)", config.name, identity.id);
+  log.server("Home: %s", getLatticeHome());
 
   var clientDir = join(import.meta.dir, "../../client/dist");
 
@@ -201,7 +208,7 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
         cert: readFileSync(certs.cert),
         key: readFileSync(certs.key),
       };
-      console.log("[lattice] TLS enabled");
+      log.server("TLS enabled");
     } catch (err) {
       console.error("[lattice] Failed to load TLS certs, falling back to HTTP:", err);
     }
@@ -291,16 +298,28 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
     websocket: {
       open(ws: ServerWebSocket<WsData>) {
         addClient(ws);
-        console.log(`[lattice] Client connected: ${ws.data.id}`);
+        log.ws("Client connected: %s", ws.data.id);
         sendTo(ws.data.id, { type: "mesh:nodes", nodes: buildNodesMessage() });
       },
       message(ws: ServerWebSocket<WsData>, message: string | Buffer) {
+        var now = Date.now();
+        var limit = clientRateLimits.get(ws.data.id);
+        if (!limit || now - limit.windowStart > RATE_LIMIT_WINDOW) {
+          limit = { count: 0, windowStart: now };
+          clientRateLimits.set(ws.data.id, limit);
+        }
+        limit.count++;
+        if (limit.count > RATE_LIMIT_MAX) {
+          sendTo(ws.data.id, { type: "chat:error", message: "Rate limit exceeded, please slow down" });
+          return;
+        }
+
         var text = typeof message === "string" ? message : message.toString();
         try {
           var msg = JSON.parse(text) as ClientMessage;
           routeMessage(ws.data.id, msg);
         } catch (err) {
-          console.error("[lattice] Invalid JSON message:", err);
+          log.ws("Invalid JSON message: %O", err);
         }
       },
       close(ws: ServerWebSocket<WsData>) {
@@ -309,16 +328,19 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
           unwatchSessionLock(activeSession.sessionId);
         }
         clearActiveSession(ws.data.id);
+        clearActiveProject(ws.data.id);
+        clearClientRemoteNode(ws.data.id);
         removeClient(ws.data.id);
         cleanupClientTerminals(ws.data.id);
         cleanupClientAttachments(ws.data.id);
         cleanupClientPermissions(ws.data.id);
-        console.log(`[lattice] Client disconnected: ${ws.data.id}`);
+        clientRateLimits.delete(ws.data.id);
+        log.ws("Client disconnected: %s", ws.data.id);
       },
     },
   });
 
-  console.log(`[lattice] Listening on ${protocol}://0.0.0.0:${config.port}`);
+  log.server("Listening on %s://0.0.0.0:%d", protocol, config.port);
 
   startDiscovery(identity.id, config.name, config.port);
 

package/server/src/handlers/attachment.ts

@@ -3,10 +3,13 @@ import type { AttachmentChunkMessage, AttachmentCompleteMessage, ClientMessage }
 import { registerHandler } from "../ws/router";
 import { sendTo } from "../ws/broadcast";
 
+var MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
+
 interface PendingUpload {
   chunks: Map<number, Buffer>;
   totalChunks: number;
   receivedCount: number;
+  totalBytes: number;
   createdAt: number;
 }
 
@@ -45,6 +48,7 @@ registerHandler("attachment", function (clientId: string, message: ClientMessage
         chunks: new Map(),
         totalChunks: msg.totalChunks,
         receivedCount: 0,
+        totalBytes: 0,
         createdAt: Date.now(),
       };
       store.set(msg.attachmentId, pending);
@@ -59,8 +63,20 @@ registerHandler("attachment", function (clientId: string, message: ClientMessage
       return;
     }
 
-    pending.chunks.set(msg.chunkIndex, Buffer.from(msg.data, "base64"));
+    var chunkBuffer = Buffer.from(msg.data, "base64");
+    if (pending.totalBytes + chunkBuffer.length > MAX_ATTACHMENT_SIZE) {
+      store.delete(msg.attachmentId);
+      sendTo(clientId, {
+        type: "attachment:error",
+        attachmentId: msg.attachmentId,
+        error: "Attachment exceeds maximum size of " + (MAX_ATTACHMENT_SIZE / 1024 / 1024) + "MB",
+      });
+      return;
+    }
+
+    pending.chunks.set(msg.chunkIndex, chunkBuffer);
     pending.receivedCount++;
+    pending.totalBytes += chunkBuffer.length;
 
     sendTo(clientId, {
       type: "attachment:progress",

package/server/src/handlers/session.ts

@@ -25,6 +25,7 @@ import { getContextBreakdown } from "../project/context-breakdown";
 import { setActiveSession } from "./chat";
 import { setActiveProject } from "./fs";
 import { wasSessionInterrupted, clearInterruptedFlag, isSessionBusy, watchSessionLock, stopExternalSession } from "../project/sdk-bridge";
+import { log } from "../logger";
 
 registerHandler("session", function (clientId: string, message: ClientMessage) {
   if (message.type === "session:list_request") {
@@ -89,45 +90,73 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     setActiveProject(clientId, activateMsg.projectSlug);
     watchSessionLock(activateMsg.sessionId);
     void Promise.all([
-      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId),
-      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId),
-      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId),
-      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId),
+      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;
+      }),
     ]).then(function (results) {
-      var interrupted = wasSessionInterrupted(activateMsg.sessionId);
-      if (interrupted) {
-        clearInterruptedFlag(activateMsg.sessionId);
-      }
-      var busy = isSessionBusy(activateMsg.sessionId);
-      sendTo(clientId, {
-        type: "session:history",
-        projectSlug: activateMsg.projectSlug,
-        sessionId: activateMsg.sessionId,
-        messages: results[0],
-        title: results[1],
-        interrupted: interrupted || undefined,
-        busy: busy || undefined,
-      });
-      var usage = results[2];
-      if (usage) {
+      try {
+        var interrupted = wasSessionInterrupted(activateMsg.sessionId);
+        if (interrupted) {
+          clearInterruptedFlag(activateMsg.sessionId);
+        }
+        var busy = isSessionBusy(activateMsg.sessionId);
         sendTo(clientId, {
-          type: "chat:context_usage",
-          inputTokens: usage.inputTokens,
-          outputTokens: usage.outputTokens,
-          cacheReadTokens: usage.cacheReadTokens,
-          cacheCreationTokens: usage.cacheCreationTokens,
-          contextWindow: usage.contextWindow,
+          type: "session:history",
+          projectSlug: activateMsg.projectSlug,
+          sessionId: activateMsg.sessionId,
+          messages: results[0] || [],
+          title: results[1],
+          interrupted: interrupted || undefined,
+          busy: busy || undefined,
         });
+      } catch (err) {
+        log.session("Error sending session history: %O", err);
+        sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
       }
-      var breakdown = results[3];
-      if (breakdown) {
-        sendTo(clientId, {
-          type: "chat:context_breakdown",
-          segments: breakdown.segments,
-          contextWindow: breakdown.contextWindow,
-          autocompactAt: breakdown.autocompactAt,
-        });
+      try {
+        var usage = results[2];
+        if (usage) {
+          sendTo(clientId, {
+            type: "chat:context_usage",
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+            contextWindow: usage.contextWindow,
+          });
+        }
+      } catch (err) {
+        log.session("Error sending context usage: %O", err);
+      }
+      try {
+        var breakdown = results[3];
+        if (breakdown) {
+          sendTo(clientId, {
+            type: "chat:context_breakdown",
+            segments: breakdown.segments,
+            contextWindow: breakdown.contextWindow,
+            autocompactAt: breakdown.autocompactAt,
+          });
+        }
+      } catch (err) {
+        log.session("Error sending context breakdown: %O", err);
       }
+    }).catch(function (err) {
+      log.session("Failed to activate session: %O", err);
+      sendTo(clientId, { type: "chat:error", message: "Failed to activate session" });
     });
     return;
   }
@@ -175,7 +204,7 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     var stopMsg = message as { type: string; sessionId: string };
     var stopped = stopExternalSession(stopMsg.sessionId);
     if (stopped) {
-      console.log("[lattice] Sent SIGINT to external CLI process for session " + stopMsg.sessionId);
+      log.session("Sent SIGINT to external CLI process for session %s", stopMsg.sessionId);
     } else {
       sendTo(clientId, { type: "chat:error", message: "No external process found for this session." });
     }

package/server/src/index.ts

@@ -82,14 +82,33 @@ switch (command) {
 async function runDaemon(): Promise<void> {
   var { startDaemon } = await import("./daemon");
   writePid(process.pid);
-  process.on("SIGTERM", function () {
-    removePid();
-    process.exit(0);
-  });
-  process.on("SIGINT", function () {
-    removePid();
-    process.exit(0);
-  });
+  var shutdownInProgress = false;
+  function gracefulShutdown(): void {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    console.log("[lattice] Shutting down gracefully...");
+
+    var { broadcast, closeAllClients } = require("./ws/broadcast") as typeof import("./ws/broadcast");
+    var { getActiveStreamCount } = require("./project/sdk-bridge") as typeof import("./project/sdk-bridge");
+    var { stopMeshConnections } = require("./mesh/connector") as typeof import("./mesh/connector");
+
+    broadcast({ type: "chat:error", message: "Server is shutting down" });
+    stopMeshConnections();
+
+    var waited = 0;
+    var checkInterval = setInterval(function () {
+      var activeCount = getActiveStreamCount();
+      waited += 500;
+      if (activeCount === 0 || waited >= 5000) {
+        clearInterval(checkInterval);
+        closeAllClients();
+        removePid();
+        process.exit(0);
+      }
+    }, 500);
+  }
+  process.on("SIGTERM", gracefulShutdown);
+  process.on("SIGINT", gracefulShutdown);
   await startDaemon(portOverride);
 }
 

package/server/src/logger.ts

@@ -0,0 +1,12 @@
+import createDebug from "debug";
+
+export var log = {
+  server: createDebug("lattice:server"),
+  ws: createDebug("lattice:ws"),
+  chat: createDebug("lattice:chat"),
+  session: createDebug("lattice:session"),
+  mesh: createDebug("lattice:mesh"),
+  auth: createDebug("lattice:auth"),
+  fs: createDebug("lattice:fs"),
+  analytics: createDebug("lattice:analytics"),
+};