@cryptiklemur/lattice 1.37.2 → 1.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "1.37.2",
+  "version": "1.39.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/src/handlers/mesh.ts

@@ -1,4 +1,5 @@
 import type { ClientMessage, MeshPairMessage, MeshUnpairMessage, NodeInfo } from "@lattice/shared";
+import { log } from "../logger";
 import { registerHandler } from "../ws/router";
 import { sendTo, broadcast } from "../ws/broadcast";
 import { loadConfig } from "../config";
@@ -122,6 +123,8 @@ export function buildNodesMessage(): NodeInfo[] {
 }
 
 registerHandler("mesh", function (clientId: string, message: ClientMessage) {
+  log.meshHello("mesh message: %s from %s", (message as any).type, clientId.slice(0, 8));
+
   if (message.type === "mesh:generate_invite") {
     var genMsg = message as any as { type: "mesh:generate_invite"; address?: string };
     var config = loadConfig();
@@ -232,14 +235,17 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
     var hello = message as any as { type: "mesh:hello"; nodeId: string; name: string; publicKey?: string; token?: string; port?: number; addresses?: string[]; projects: Array<{ slug: string; title: string }> };
 
     var knownPeer = hello.nodeId ? getPeer(hello.nodeId) : undefined;
+    log.meshHello("mesh:hello from nodeId=%s name=%s known=%s", hello.nodeId?.slice(0, 8), hello.name, !!knownPeer);
 
     if (knownPeer) {
       if (knownPeer.publicKey && hello.publicKey && knownPeer.publicKey !== hello.publicKey) {
+        log.meshHello("  ✗ public key mismatch for %s", hello.name);
         sendTo(clientId, { type: "mesh:hello_rejected" as any, error: "Public key mismatch — possible impersonation" });
         return;
       }
 
       var inboundWs = getClientWebSocket(clientId);
+      log.meshHello("  registering inbound connection for %s (ws=%s)", hello.name, !!inboundWs);
       if (inboundWs) {
         registerInboundPeer(hello.nodeId, inboundWs as any);
       }

package/server/src/index.ts

@@ -72,15 +72,35 @@ switch (command) {
   case "stop":
     runStop();
     break;
+  case "restart":
+    runRestart();
+    break;
   case "status":
     runStatus();
     break;
   case "update":
     await runUpdate();
     break;
+  case "version":
+    await runVersion();
+    break;
+  case "logs":
+    runLogs();
+    break;
+  case "open":
+    runOpen();
+    break;
+  case "config":
+    runConfigInfo();
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+    runHelp();
+    break;
   default:
     console.log("[lattice] Unknown command: " + command);
-    console.log("[lattice] Usage: lattice [start|stop|status|update|daemon]");
+    runHelp();
     process.exit(1);
 }
 
@@ -180,6 +200,142 @@ function runStop(): void {
   }
 }
 
+function runHelp(): void {
+  console.log("");
+  console.log("  lattice — Multi-machine agentic dashboard for Claude Code");
+  console.log("");
+  console.log("  Usage: lattice [command] [options]");
+  console.log("");
+  console.log("  Commands:");
+  console.log("    start      Start the daemon and open the UI (default)");
+  console.log("    stop       Stop the running daemon");
+  console.log("    restart    Stop and restart the daemon");
+  console.log("    status     Show daemon status and connection info");
+  console.log("    update     Check for updates and install the latest version");
+  console.log("    version    Show current and latest version");
+  console.log("    logs       Tail the daemon log");
+  console.log("    open       Open the UI in the browser");
+  console.log("    config     Show configuration paths and settings");
+  console.log("    help       Show this help message");
+  console.log("");
+  console.log("  Options:");
+  console.log("    --port=N   Override the server port");
+  console.log("");
+  console.log("  Environment:");
+  console.log("    LATTICE_HOME   Data directory (default: ~/.lattice)");
+  console.log("    LATTICE_PORT   Server port (default: 7654)");
+  console.log("    DEBUG          Enable debug logging (e.g. DEBUG=lattice:*)");
+  console.log("                   Scopes: server,ws,router,mesh,mesh:connect,mesh:hello,");
+  console.log("                   mesh:proxy,broadcast,chat,session,plugins,update");
+  console.log("");
+}
+
+function runRestart(): void {
+  var pid = readPid();
+  if (pid !== null && isDaemonRunning(pid)) {
+    console.log("[lattice] Stopping daemon (PID " + pid + ")...");
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+    removePid();
+
+    var waited = 0;
+    while (waited < 5000) {
+      try {
+        process.kill(pid, 0);
+        Bun.sleepSync(200);
+        waited += 200;
+      } catch {
+        break;
+      }
+    }
+  }
+
+  console.log("[lattice] Starting daemon...");
+  var logPath = join(getLatticeHome(), "daemon.log");
+
+  var spawnArgs = IS_COMPILED
+    ? [process.execPath, "daemon"]
+    : ["bun", import.meta.path, "daemon"];
+
+  if (portOverride) {
+    spawnArgs.push("--port", String(portOverride));
+  }
+
+  var child = Bun.spawn(spawnArgs, {
+    detached: true,
+    stdio: ["ignore", Bun.file(logPath), Bun.file(logPath)],
+  });
+
+  child.unref();
+  writePid(child.pid);
+  console.log("[lattice] Daemon started (PID " + child.pid + ")");
+}
+
+async function runVersion(): Promise<void> {
+  var { checkForUpdate } = await import("./update-checker");
+  var info = await checkForUpdate(true);
+  console.log("[lattice] Current: v" + info.currentVersion);
+  if (info.latestVersion) {
+    if (info.updateAvailable) {
+      console.log("[lattice] Latest:  v" + info.latestVersion + " (update available)");
+      console.log("[lattice] Run 'lattice update' to install");
+    } else {
+      console.log("[lattice] Latest:  v" + info.latestVersion + " (up to date)");
+    }
+  }
+  console.log("[lattice] Mode:    " + info.installMode);
+}
+
+function runLogs(): void {
+  var logPath = join(getLatticeHome(), "daemon.log");
+  if (!existsSync(logPath)) {
+    console.log("[lattice] No log file found at " + logPath);
+    process.exit(1);
+  }
+  console.log("[lattice] Tailing " + logPath + " (Ctrl+C to stop)");
+  var proc = Bun.spawn(["tail", "-f", "-n", "50", logPath], {
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  process.on("SIGINT", function () {
+    proc.kill();
+    process.exit(0);
+  });
+}
+
+function runOpen(): void {
+  var config = loadConfig();
+  var pid = readPid();
+  if (pid === null || !isDaemonRunning(pid)) {
+    console.log("[lattice] Daemon is not running. Start it with 'lattice start'");
+    process.exit(1);
+  }
+  var url = (config.tls ? "https" : "http") + "://localhost:" + config.port;
+  console.log("[lattice] Opening " + url);
+  openBrowser(url);
+}
+
+function runConfigInfo(): void {
+  var config = loadConfig();
+  var home = getLatticeHome();
+  console.log("[lattice] Home:       " + home);
+  console.log("[lattice] Config:     " + join(home, "config.json"));
+  console.log("[lattice] Port:       " + config.port);
+  console.log("[lattice] Name:       " + config.name);
+  console.log("[lattice] TLS:        " + (config.tls ? "enabled" : "disabled"));
+  console.log("[lattice] Projects:   " + config.projects.length);
+  for (var i = 0; i < config.projects.length; i++) {
+    console.log("             " + config.projects[i].slug + " → " + config.projects[i].path);
+  }
+  if (config.passphraseHash) {
+    console.log("[lattice] Passphrase: set");
+  }
+  if (config.costBudget) {
+    console.log("[lattice] Budget:     $" + config.costBudget.dailyLimit + "/day (" + config.costBudget.enforcement + ")");
+  }
+}
+
 function runStatus(): void {
   var pid = readPid();
   if (pid === null) {

package/server/src/logger.ts

@@ -6,7 +6,16 @@ export var log = {
   chat: createDebug("lattice:chat"),
   session: createDebug("lattice:session"),
   mesh: createDebug("lattice:mesh"),
+  meshConnect: createDebug("lattice:mesh:connect"),
+  meshHello: createDebug("lattice:mesh:hello"),
+  meshProxy: createDebug("lattice:mesh:proxy"),
+  router: createDebug("lattice:router"),
+  broadcast: createDebug("lattice:broadcast"),
   auth: createDebug("lattice:auth"),
   fs: createDebug("lattice:fs"),
   analytics: createDebug("lattice:analytics"),
+  plugins: createDebug("lattice:plugins"),
+  update: createDebug("lattice:update"),
+  terminal: createDebug("lattice:terminal"),
+  settings: createDebug("lattice:settings"),
 };

package/server/src/mesh/connector.ts

@@ -46,11 +46,18 @@ function reconcilePeers(): void {
   var peers = loadPeers();
   for (var i = 0; i < peers.length; i++) {
     var peer = peers[i];
-    if (!peer.addresses || peer.addresses.length === 0) continue;
+    if (!peer.addresses || peer.addresses.length === 0) {
+      log.meshConnect("skip %s — no addresses", peer.name);
+      continue;
+    }
     var existing = connections.get(peer.id);
     if (existing && !existing.dead && existing.ws.readyState === WebSocket.OPEN) continue;
-    if (existing && !existing.dead && existing.retryTimer !== null) continue;
+    if (existing && !existing.dead && existing.retryTimer !== null) {
+      log.meshConnect("skip %s — retry pending", peer.name);
+      continue;
+    }
     if (!existing || existing.dead) {
+      log.meshConnect("connecting to %s at %s", peer.name, peer.addresses[0]);
       connections.delete(peer.id);
       connectToPeer(peer.id, peer.addresses[0]);
     }
@@ -103,6 +110,7 @@ function openConnection(conn: PeerConnection, url: string): void {
   var circuit = circuitBreakers.get(conn.nodeId);
   if (circuit && circuit.failures >= CIRCUIT_BREAKER_THRESHOLD && !circuit.halfOpen) {
     if (Date.now() < circuit.openUntil) {
+      log.meshConnect("circuit breaker open for %s, retry in %dms", conn.nodeId.slice(0, 8), circuit.openUntil - Date.now());
       conn.retryTimer = setTimeout(function () {
         if (conn.dead) return;
         conn.retryTimer = null;
@@ -114,12 +122,13 @@ function openConnection(conn: PeerConnection, url: string): void {
     circuit.halfOpen = true;
   }
 
+  log.meshConnect("opening WebSocket to %s", url);
   var ws = new WebSocket(url);
   conn.ws = ws;
 
   var connectionTimer = setTimeout(function () {
     if (ws.readyState !== WebSocket.OPEN) {
-      log.mesh("Connection timeout for peer: %s", conn.nodeId);
+      log.meshConnect("connection timeout for %s at %s", conn.nodeId.slice(0, 8), url);
       ws.close();
     }
   }, CONNECTION_TIMEOUT_MS);
@@ -242,8 +251,10 @@ export function getPeerConnection(nodeId: string): WebSocket | undefined {
 export function registerInboundPeer(nodeId: string, ws: { send: (data: string) => void; readyState: number }): void {
   var existing = connections.get(nodeId);
   if (existing && !existing.dead && existing.ws.readyState === WebSocket.OPEN) {
+    log.meshConnect("inbound peer %s already connected, skipping", nodeId.slice(0, 8));
     return;
   }
+  log.meshConnect("registering inbound peer %s", nodeId.slice(0, 8));
 
   if (existing) {
     existing.dead = true;

package/server/src/mesh/proxy.ts

@@ -3,19 +3,22 @@ import type { ClientMessage, MeshProxyRequestMessage, MeshProxyResponseMessage,
 import { getPeerConnection } from "./connector";
 import { sendTo, broadcast, registerVirtualClient, removeVirtualClient } from "../ws/broadcast";
 import { routeMessage } from "../ws/router";
+import { log } from "../logger";
 
 var pendingRequests = new Map<string, string>();
 
 export function proxyToRemoteNode(nodeId: string, projectSlug: string, clientId: string, message: ClientMessage): void {
+  log.meshProxy("→ proxy %s to node %s for project %s", (message as any).type, nodeId.slice(0, 8), projectSlug);
   var ws = getPeerConnection(nodeId);
   if (!ws) {
-    console.warn("[mesh/proxy] No connection to peer: " + nodeId);
-    sendTo(clientId, { type: "chat:error", message: "Remote node " + nodeId + " is not connected" });
+    log.meshProxy("  ✗ no connection to node %s", nodeId.slice(0, 8));
+    sendTo(clientId, { type: "chat:error", message: "Remote node is not connected" });
     return;
   }
 
   var requestId = randomUUID();
   pendingRequests.set(requestId, clientId);
+  log.meshProxy("  envelope requestId=%s", requestId.slice(0, 8));
 
   var envelope: MeshProxyRequestMessage = {
     type: "mesh:proxy_request",
@@ -29,8 +32,10 @@ export function proxyToRemoteNode(nodeId: string, projectSlug: string, clientId:
 
 export function handleProxyRequest(sourceNodeId: string, msg: MeshProxyRequestMessage): void {
   var proxyClientId = "mesh-proxy:" + sourceNodeId + ":" + msg.requestId;
+  log.meshProxy("← proxy_request from %s: %s for %s (reqId=%s)", sourceNodeId.slice(0, 8), (msg.payload as any).type, msg.projectSlug, msg.requestId.slice(0, 8));
 
   registerVirtualClient(proxyClientId, function (response: object) {
+    log.meshProxy("  → proxy_response %s back to %s", (response as any).type, sourceNodeId.slice(0, 8));
     var ws = getPeerConnection(sourceNodeId);
     if (!ws) {
       console.warn("[mesh/proxy] Cannot send response, no connection to: " + sourceNodeId);
@@ -53,9 +58,10 @@ export function handleProxyRequest(sourceNodeId: string, msg: MeshProxyRequestMe
 }
 
 export function handleProxyResponse(msg: MeshProxyResponseMessage): void {
+  log.meshProxy("← proxy_response %s (reqId=%s)", (msg.payload as any).type, msg.requestId.slice(0, 8));
   var clientId = pendingRequests.get(msg.requestId);
   if (!clientId) {
-    console.warn("[mesh/proxy] No pending request for id: " + msg.requestId);
+    log.meshProxy("  ✗ no pending request for %s", msg.requestId.slice(0, 8));
     return;
   }
 

package/server/src/ws/broadcast.ts

@@ -37,6 +37,11 @@ export function sendTo(id: string, message: object): void {
   var virtualHandler = virtualSendHandlers.get(id);
   if (virtualHandler) {
     virtualHandler(message);
+    return;
+  }
+  if (id.startsWith("mesh-proxy:")) {
+    var { log } = require("../logger");
+    log.broadcast("  ✗ sendTo %s but no virtual handler registered (msg=%s)", id.slice(0, 30), (message as any).type);
   }
 }
 

package/server/src/ws/router.ts

@@ -53,6 +53,8 @@ export function getClientRemoteNode(clientId: string): { nodeId: string; project
 export function routeMessage(clientId: string, message: ClientMessage): void {
   var prefix = message.type.split(":")[0];
 
+  log.router("→ %s from client %s (prefix=%s)", message.type, clientId.slice(0, 8), prefix);
+
   if (PROXIED_PREFIXES.has(prefix)) {
     var remote = clientRemoteNode.get(clientId);
 
@@ -60,17 +62,21 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
 
     if (msgSlug) {
       var localProject = getLocalProject(msgSlug);
+      log.router("  slug=%s local=%s", msgSlug, localProject);
       if (!localProject) {
         var remoteEntry = getRemoteNodeForProject(msgSlug);
         if (remoteEntry) {
+          log.router("  → proxying to remote node %s for project %s", remoteEntry.nodeId.slice(0, 8), msgSlug);
           setClientRemoteNode(clientId, remoteEntry.nodeId, msgSlug);
           proxyMessage(clientId, remoteEntry.nodeId, msgSlug, message);
           return;
         }
+        log.router("  ✗ no remote node found for slug %s", msgSlug);
       } else if (message.type === "session:activate" || message.type === "session:list_request") {
         clearClientRemoteNode(clientId);
       }
     } else if (remote) {
+      log.router("  → proxying via cached remote node %s", remote.nodeId.slice(0, 8));
       proxyMessage(clientId, remote.nodeId, remote.projectSlug, message);
       return;
     }
@@ -78,6 +84,7 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
 
   var handler = handlers.get(prefix);
   if (handler) {
+    log.router("  → dispatching to %s handler", prefix);
     try {
       var result = handler(clientId, message);
       if (result && typeof result.then === "function") {
@@ -94,7 +101,7 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
     }
     return;
   }
-  log.ws("No handler for message type: %s", message.type);
+  log.router("  ✗ no handler for %s", message.type);
   sendTo(clientId, { type: "error", message: `Unknown message type: ${message.type}` });
 }