@cryptiklemur/lattice 1.29.1 → 1.30.0

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

@@ -22,6 +22,8 @@ export var PairingDialog = memo(function PairingDialog(props: PairingDialogProps
   var [pairError, setPairError] = useState<string | null>(null);
   var [copied, setCopied] = useState(false);
   var [generating, setGenerating] = useState(false);
+  var [addresses, setAddresses] = useState<Array<{ name: string; address: string }>>([]);
+  var [selectedAddress, setSelectedAddress] = useState("");
   var modalRef = useRef<HTMLDivElement>(null);
   var inputRef = useRef<HTMLInputElement>(null);
 
@@ -33,14 +35,32 @@ export var PairingDialog = memo(function PairingDialog(props: PairingDialogProps
       setPairError(null);
       setCopied(false);
       setGenerating(false);
+      setAddresses([]);
+      setSelectedAddress("");
       setTab("generate");
       return;
     }
+
+    function handleAddresses(msg: ServerMessage) {
+      if ((msg as any).type !== "mesh:addresses_result") return;
+      var data = msg as any as { addresses: Array<{ name: string; address: string }> };
+      setAddresses(data.addresses);
+      if (data.addresses.length > 0) {
+        setSelectedAddress(data.addresses[0].address);
+      }
+    }
+
+    ws.subscribe("mesh:addresses_result", handleAddresses);
+    ws.send({ type: "mesh:addresses" } as any);
+
     function handleKeyDown(e: KeyboardEvent) {
       if (e.key === "Escape") props.onClose();
     }
     document.addEventListener("keydown", handleKeyDown);
-    return function () { document.removeEventListener("keydown", handleKeyDown); };
+    return function () {
+      document.removeEventListener("keydown", handleKeyDown);
+      ws.unsubscribe("mesh:addresses_result", handleAddresses);
+    };
   }, [props.isOpen]);
 
   useEffect(function () {
@@ -77,7 +97,7 @@ export var PairingDialog = memo(function PairingDialog(props: PairingDialogProps
   function handleGenerateInvite() {
     clearInvite();
     setGenerating(true);
-    mesh.generateInvite();
+    ws.send({ type: "mesh:generate_invite", address: selectedAddress } as any);
   }
 
   function handlePair() {
@@ -172,9 +192,31 @@ export var PairingDialog = memo(function PairingDialog(props: PairingDialogProps
                 The code encodes this node&apos;s address and a one-time auth token.
               </div>
 
+              {!mesh.inviteCode && !generating && addresses.length > 1 && (
+                <div className="mb-3">
+                  <label className="text-[11px] font-mono text-base-content/35 uppercase tracking-wider mb-1.5 block">
+                    Network interface
+                  </label>
+                  <select
+                    value={selectedAddress}
+                    onChange={function (e) { setSelectedAddress(e.target.value); }}
+                    className="select select-bordered select-sm w-full bg-base-100 text-base-content text-[13px] font-mono"
+                  >
+                    {addresses.map(function (a) {
+                      return (
+                        <option key={a.address} value={a.address}>
+                          {a.address} ({a.name})
+                        </option>
+                      );
+                    })}
+                  </select>
+                </div>
+              )}
+
               {!mesh.inviteCode && !generating && (
                 <button
                   onClick={handleGenerateInvite}
+                  disabled={!selectedAddress && addresses.length > 0}
                   className="btn btn-primary btn-sm"
                 >
                   Generate Invite Code

package/package.json

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

@@ -4,24 +4,30 @@ 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 {
+  var all = getAllAddresses();
+  return all.length > 0 ? all[0].address : "localhost";
+}
+
+function getAllAddresses(): Array<{ name: string; address: string }> {
   var interfaces = networkInterfaces();
   var keys = Object.keys(interfaces);
+  var results: Array<{ name: string; address: string }> = [];
   for (var i = 0; i < keys.length; i++) {
     var addrs = interfaces[keys[i]];
     if (!addrs) continue;
     for (var j = 0; j < addrs.length; j++) {
       if (!addrs[j].internal && addrs[j].family === "IPv4") {
-        return addrs[j].address;
+        results.push({ name: keys[i], address: addrs[j].address });
       }
     }
   }
-  return "localhost";
+  return results;
 }
-import { addPeer, removePeer, loadPeers } from "../mesh/peers";
-import type { PeerInfo } from "@lattice/shared";
 
 export function buildNodesMessage(): NodeInfo[] {
   var peers = loadPeers();
@@ -57,8 +63,9 @@ export function buildNodesMessage(): NodeInfo[] {
 
 registerHandler("mesh", function (clientId: string, message: ClientMessage) {
   if (message.type === "mesh:generate_invite") {
+    var genMsg = message as any as { type: "mesh:generate_invite"; address?: string };
     var config = loadConfig();
-    var address = getLocalAddress();
+    var address = genMsg.address || getLocalAddress();
     generateInviteCode(address, config.port).then(function (result) {
       sendTo(clientId, {
         type: "mesh:invite_code",
@@ -71,6 +78,12 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
     return;
   }
 
+  if ((message as any).type === "mesh:addresses") {
+    var addresses = getAllAddresses();
+    sendTo(clientId, { type: "mesh:addresses_result" as any, addresses: addresses });
+    return;
+  }
+
   if (message.type === "mesh:pair") {
     var pairMsg = message as MeshPairMessage;
     var parsed = parseInviteCode(pairMsg.code);
@@ -78,27 +91,38 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
       sendTo(clientId, { type: "mesh:pair_failed", message: "Invalid invite code format" });
       return;
     }
-    if (!validatePairingToken(parsed.token)) {
-      sendTo(clientId, { type: "mesh:pair_failed", message: "Invite code is invalid or expired" });
-      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 +131,7 @@ registerHandler("mesh", function (clientId: string, message: ClientMessage) {
             pairedAt: Date.now(),
           };
           addPeer(peer);
-          ws.close();
+          pairWs.close();
 
           var nodeInfo: NodeInfo = {
             id: peer.id,
@@ -125,13 +149,44 @@ 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);
+
+    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;
+  }
+
   if (message.type === "mesh:unpair") {
     var unpairMsg = message as MeshUnpairMessage;
     var removed = removePeer(unpairMsg.nodeId);