@cryptiklemur/lattice 1.29.0 → 1.29.2

package/client/src/components/mesh/PairingDialog.tsx

@@ -57,11 +57,20 @@ export var PairingDialog = memo(function PairingDialog(props: PairingDialogProps
       }
     }
 
+    function handlePairFailed(msg: ServerMessage) {
+      if (msg.type !== "mesh:pair_failed") return;
+      var data = msg as { type: string; message: string };
+      setPairStatus("failed");
+      setPairError(data.message);
+    }
+
     ws.subscribe("mesh:invite_code", handleInvite);
     ws.subscribe("mesh:paired", handlePaired);
+    ws.subscribe("mesh:pair_failed", handlePairFailed);
     return function () {
       ws.unsubscribe("mesh:invite_code", handleInvite);
       ws.unsubscribe("mesh:paired", handlePaired);
+      ws.unsubscribe("mesh:pair_failed", handlePairFailed);
     };
   }, []);
 
@@ -220,8 +229,9 @@ export var PairingDialog = memo(function PairingDialog(props: PairingDialogProps
                 type="text"
                 value={pairCode}
                 onChange={function (e) {
-                  var raw = e.target.value.toUpperCase().replace(/[^A-Z0-9]/g, "");
-                  if (raw.startsWith("LTCE")) raw = raw.slice(4);
+                  var raw = e.target.value.replace(/[^A-Za-z0-9]/g, "");
+                  var upper = raw.toUpperCase();
+                  if (upper.startsWith("LTCE")) raw = raw.slice(4);
                   if (raw.length > 16) raw = raw.slice(0, 16);
                   var chunks: string[] = [];
                   for (var i = 0; i < raw.length; i += 4) {

package/package.json

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

@@ -4,6 +4,8 @@ import { sendTo, broadcast } from "../ws/broadcast";
 import { loadConfig } from "../config";
 import { loadOrCreateIdentity } from "../identity";
 import { generateInviteCode, parseInviteCode, validatePairingToken, consumePairingToken } from "../mesh/pairing";
+import { addPeer, removePeer, loadPeers } from "../mesh/peers";
+import type { PeerInfo } from "@lattice/shared";
 import { networkInterfaces } from "node:os";
 
 function getLocalAddress(): string {
@@ -20,8 +22,6 @@ function getLocalAddress(): string {
   }
   return "localhost";
 }
-import { addPeer, removePeer, loadPeers } from "../mesh/peers";
-import type { PeerInfo } from "@lattice/shared";
 
 export function buildNodesMessage(): NodeInfo[] {
   var peers = loadPeers();
@@ -75,30 +75,41 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
     var pairMsg = message as MeshPairMessage;
     var parsed = parseInviteCode(pairMsg.code);
     if (!parsed) {
-      sendTo(clientId, { type: "chat:error", message: "Invalid invite code format" });
-      return;
-    }
-    if (!validatePairingToken(parsed.token)) {
-      sendTo(clientId, { type: "chat:error", message: "Invite code is invalid or expired" });
+      sendTo(clientId, { type: "mesh:pair_failed", message: "Invalid invite code format" });
       return;
     }
-    consumePairingToken(parsed.token);
 
     var wsUrl = "ws://" + parsed.address + ":" + parsed.port + "/ws";
-    var ws = new WebSocket(wsUrl);
-    ws.addEventListener("open", function () {
+    var pairWs = new WebSocket(wsUrl);
+    var pairTimeout = setTimeout(function () {
+      pairWs.close();
+      sendTo(clientId, { type: "mesh:pair_failed", message: "Connection timed out" });
+    }, 15000);
+
+    pairWs.addEventListener("open", function () {
       var identity = loadOrCreateIdentity();
-      ws.send(JSON.stringify({
+      pairWs.send(JSON.stringify({
         type: "mesh:hello",
         nodeId: identity.id,
         name: loadConfig().name,
+        token: parsed!.token,
         projects: [],
       }));
     });
-    ws.addEventListener("message", function (event: MessageEvent) {
+
+    pairWs.addEventListener("message", function (event: MessageEvent) {
       try {
-        var data = JSON.parse(event.data as string) as { type: string; nodeId?: string; name?: string };
+        var data = JSON.parse(event.data as string) as { type: string; nodeId?: string; name?: string; error?: string };
+
+        if (data.type === "mesh:hello_rejected") {
+          clearTimeout(pairTimeout);
+          pairWs.close();
+          sendTo(clientId, { type: "mesh:pair_failed", message: data.error ?? "Pairing rejected by remote node" });
+          return;
+        }
+
         if (data.type === "mesh:hello" && data.nodeId && data.name) {
+          clearTimeout(pairTimeout);
           var peer: PeerInfo = {
             id: data.nodeId,
             name: data.name,
@@ -107,7 +118,7 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
             pairedAt: Date.now(),
           };
           addPeer(peer);
-          ws.close();
+          pairWs.close();
 
           var nodeInfo: NodeInfo = {
             id: peer.id,
@@ -125,10 +136,41 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
         console.error("[lattice] mesh:pair — invalid handshake response");
       }
     });
-    ws.addEventListener("error", function () {
-      console.error("[lattice] mesh:pair — failed to connect to", wsUrl);
-      sendTo(clientId, { type: "chat:error", message: "Failed to connect to " + parsed!.address + ":" + parsed!.port });
+
+    pairWs.addEventListener("error", function () {
+      clearTimeout(pairTimeout);
+      sendTo(clientId, { type: "mesh:pair_failed", message: "Failed to connect to " + parsed!.address + ":" + parsed!.port });
+    });
+    return;
+  }
+
+  if ((message as any).type === "mesh:hello") {
+    var hello = message as any as { type: "mesh:hello"; nodeId: string; name: string; token?: string; projects: Array<{ slug: string; title: string }> };
+
+    if (!hello.token || !validatePairingToken(hello.token)) {
+      sendTo(clientId, { type: "mesh:hello_rejected" as any, error: "Invalid or expired invite code" });
+      return;
+    }
+    consumePairingToken(hello.token);
+
+    var peer: PeerInfo = {
+      id: hello.nodeId,
+      name: hello.name,
+      addresses: [],
+      publicKey: "",
+      pairedAt: Date.now(),
+    };
+    addPeer(peer);
+
+    var identity = loadOrCreateIdentity();
+    sendTo(clientId, {
+      type: "mesh:hello" as any,
+      nodeId: identity.id,
+      name: loadConfig().name,
+      projects: [],
     });
+
+    broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
     return;
   }
 

package/shared/src/messages.ts

@@ -761,6 +761,11 @@ export interface MeshPairedMessage {
   node: NodeInfo;
 }
 
+export interface MeshPairFailedMessage {
+  type: "mesh:pair_failed";
+  message: string;
+}
+
 export interface MeshNodeOnlineMessage {
   type: "mesh:node_online";
   nodeId: string;
@@ -1022,6 +1027,7 @@ export type ServerMessage =
   | MeshNodesMessage
   | MeshInviteCodeMessage
   | MeshPairedMessage
+  | MeshPairFailedMessage
   | MeshNodeOnlineMessage
   | MeshNodeOfflineMessage
   | ProjectsListMessage