@cryptiklemur/lattice 4.0.2 → 5.0.1

package/dist/server/handlers/mesh.js

@@ -0,0 +1,322 @@
+import { log } from "../logger.js";
+import { handleProxyResponse } from "../mesh/proxy.js";
+import { registerHandler } from "../ws/router.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
+import { loadConfig } from "../config.js";
+import { loadOrCreateIdentity } from "../identity.js";
+import { generateInviteCode, parseInviteCode, validatePairingToken, consumePairingToken } from "../mesh/pairing.js";
+import { addPeer, removePeer, loadPeers, getPeer } from "../mesh/peers.js";
+import { getConnectedPeerIds, connectToPeer, reconnectPeer, getPeerConnection, disconnectPeer, getConnectedPeerProjects, registerInboundPeer } from "../mesh/connector.js";
+import { getClientWebSocket, registerVirtualClient, removeVirtualClient } from "../ws/broadcast.js";
+import { networkInterfaces } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+function getLocalAddress() {
+    var all = getAllAddresses();
+    return all.length > 0 ? all[0].address : "localhost";
+}
+function getAllAddresses() {
+    var interfaces = networkInterfaces();
+    var keys = Object.keys(interfaces);
+    var results = [];
+    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") {
+                results.push({ name: keys[i], address: addrs[j].address });
+            }
+        }
+    }
+    if (isWSL()) {
+        var windowsAddrs = getWindowsHostAddresses();
+        for (var w = 0; w < windowsAddrs.length; w++) {
+            var exists = results.some(function (r) { return r.address === windowsAddrs[w].address; });
+            if (!exists) {
+                results.push(windowsAddrs[w]);
+            }
+        }
+    }
+    return results;
+}
+function isWSL() {
+    try {
+        if (existsSync("/proc/version")) {
+            var version = readFileSync("/proc/version", "utf-8");
+            return version.toLowerCase().includes("microsoft");
+        }
+    }
+    catch { }
+    return false;
+}
+function getWindowsHostAddresses() {
+    var results = [];
+    try {
+        var output = execSync("powershell.exe -NoProfile -Command \"Get-NetIPAddress -AddressFamily IPv4 | ForEach-Object { \\$_.IPAddress + '|' + \\$_.InterfaceAlias }\"", { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        var lines = output.trim().split(/\r?\n/);
+        for (var i = 0; i < lines.length; i++) {
+            var parts = lines[i].trim().split("|");
+            var ip = parts[0];
+            var iface = parts[1] || "windows";
+            if (!ip || ip === "127.0.0.1")
+                continue;
+            if (ip.startsWith("169.254."))
+                continue;
+            if (iface.includes("WSL"))
+                continue;
+            results.push({ name: iface.toLowerCase().replace(/\s+/g, "-"), address: ip });
+        }
+    }
+    catch { }
+    return results;
+}
+function getLocalProjectsList() {
+    var config = loadConfig();
+    return config.projects.map(function (p) {
+        return { slug: p.slug, title: p.title };
+    });
+}
+export function buildNodesMessage() {
+    var peers = loadPeers();
+    var config = loadConfig();
+    var identity = loadOrCreateIdentity();
+    var connectedIds = new Set(getConnectedPeerIds());
+    var localAddrs = getAllAddresses().map(function (a) { return a.address + ":" + config.port; });
+    var local = {
+        id: identity.id,
+        name: config.name,
+        address: localAddrs[0] ?? "localhost:" + config.port,
+        addresses: localAddrs.length > 0 ? localAddrs : ["localhost:" + config.port],
+        port: config.port,
+        online: true,
+        isLocal: true,
+        projects: config.projects.map(function (p) {
+            return { slug: p.slug, path: p.path, title: p.title, nodeId: identity.id };
+        }),
+    };
+    var remotes = peers.map(function (peer) {
+        var peerProjects = getConnectedPeerProjects(peer.id);
+        return {
+            id: peer.id,
+            name: peer.name,
+            address: peer.addresses[0] ?? "",
+            addresses: peer.addresses,
+            port: 0,
+            online: connectedIds.has(peer.id),
+            isLocal: false,
+            projects: peerProjects.map(function (p) {
+                return { slug: p.slug, path: "", title: p.title, nodeId: peer.id };
+            }),
+        };
+    });
+    return [local, ...remotes];
+}
+registerHandler("mesh", function (clientId, message) {
+    log.meshHello("mesh message: %s from %s", message.type, clientId.slice(0, 8));
+    if (message.type === "mesh:generate_invite") {
+        var genMsg = message;
+        var config = loadConfig();
+        var address = genMsg.address || getLocalAddress();
+        generateInviteCode(address, config.port).then(function (result) {
+            sendTo(clientId, {
+                type: "mesh:invite_code",
+                code: result.code,
+                qrDataUrl: result.qrDataUrl,
+            });
+        }).catch(function (err) {
+            console.error("[lattice] Failed to generate invite code:", err);
+        });
+        return;
+    }
+    if (message.type === "mesh:addresses") {
+        var addresses = getAllAddresses();
+        sendTo(clientId, { type: "mesh:addresses_result", addresses: addresses });
+        return;
+    }
+    if (message.type === "mesh:pair") {
+        var pairMsg = message;
+        var parsed = parseInviteCode(pairMsg.code);
+        if (!parsed) {
+            sendTo(clientId, { type: "mesh:pair_failed", message: "Invalid invite code format" });
+            return;
+        }
+        var wsUrl = "ws://" + parsed.address + ":" + parsed.port + "/ws";
+        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();
+            var pairConfig = loadConfig();
+            pairWs.send(JSON.stringify({
+                type: "mesh:hello",
+                nodeId: identity.id,
+                name: pairConfig.name,
+                publicKey: identity.publicKey,
+                token: parsed.token,
+                port: pairConfig.port,
+                addresses: getAllAddresses().map(function (a) { return a.address + ":" + pairConfig.port; }),
+                projects: getLocalProjectsList(),
+            }));
+        });
+        pairWs.addEventListener("message", function (event) {
+            try {
+                var data = JSON.parse(event.data);
+                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 peerAddr = parsed.address + ":" + parsed.port;
+                    var peer = {
+                        id: data.nodeId,
+                        name: data.name,
+                        addresses: [peerAddr],
+                        publicKey: data.publicKey ?? "",
+                        pairedAt: Date.now(),
+                    };
+                    addPeer(peer);
+                    pairWs.close();
+                    connectToPeer(peer.id, peerAddr);
+                    var remoteProjectsList = data.projects ?? [];
+                    var nodeInfo = {
+                        id: peer.id,
+                        name: peer.name,
+                        address: peerAddr,
+                        addresses: [peerAddr],
+                        port: parsed.port,
+                        online: true,
+                        isLocal: false,
+                        projects: remoteProjectsList.map(function (rp) {
+                            return { slug: rp.slug, path: "", title: rp.title, nodeId: peer.id };
+                        }),
+                    };
+                    sendTo(clientId, { type: "mesh:paired", node: nodeInfo });
+                    broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+                }
+            }
+            catch {
+                console.error("[lattice] mesh:pair — invalid handshake response");
+            }
+        });
+        pairWs.addEventListener("error", function () {
+            clearTimeout(pairTimeout);
+            sendTo(clientId, { type: "mesh:pair_failed", message: "Failed to connect to " + parsed.address + ":" + parsed.port });
+        });
+        return;
+    }
+    if (message.type === "mesh:hello") {
+        var hello = message;
+        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", error: "Public key mismatch — possible impersonation" });
+                return;
+            }
+            var inboundWs = getClientWebSocket(clientId);
+            log.meshHello("  registering inbound connection for %s (ws=%s, projects=%d)", hello.name, !!inboundWs, hello.projects?.length ?? 0);
+            if (inboundWs) {
+                registerInboundPeer(hello.nodeId, inboundWs, hello.projects ?? []);
+            }
+            var identity = loadOrCreateIdentity();
+            sendTo(clientId, {
+                type: "mesh:hello",
+                nodeId: identity.id,
+                name: loadConfig().name,
+                publicKey: identity.publicKey,
+                projects: getLocalProjectsList(),
+            });
+            broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+            return;
+        }
+        if (!hello.token || !validatePairingToken(hello.token)) {
+            sendTo(clientId, { type: "mesh:hello_rejected", error: "Invalid or expired invite code" });
+            return;
+        }
+        consumePairingToken(hello.token);
+        var peerAddresses = hello.addresses ?? [];
+        var peer = {
+            id: hello.nodeId,
+            name: hello.name,
+            addresses: peerAddresses,
+            publicKey: hello.publicKey ?? "",
+            pairedAt: Date.now(),
+        };
+        addPeer(peer);
+        if (peerAddresses.length > 0) {
+            connectToPeer(peer.id, peerAddresses[0]);
+        }
+        var identity2 = loadOrCreateIdentity();
+        sendTo(clientId, {
+            type: "mesh:hello",
+            nodeId: identity2.id,
+            name: loadConfig().name,
+            publicKey: identity2.publicKey,
+            projects: [],
+        });
+        broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+        return;
+    }
+    if (message.type === "mesh:proxy_request") {
+        var proxyReq = message;
+        log.meshProxy("received proxy_request via handler from %s: %s for %s", clientId.slice(0, 8), proxyReq.payload.type, proxyReq.projectSlug);
+        registerVirtualClient("mesh-proxy:" + clientId + ":" + proxyReq.requestId, function (response) {
+            log.meshProxy("  → sending proxy_response %s back to client %s", response.type, clientId.slice(0, 8));
+            sendTo(clientId, {
+                type: "mesh:proxy_response",
+                projectSlug: proxyReq.projectSlug,
+                requestId: proxyReq.requestId,
+                payload: response,
+            });
+            removeVirtualClient("mesh-proxy:" + clientId + ":" + proxyReq.requestId);
+        });
+        import("../ws/router.js").then(function (mod) {
+            mod.routeMessage("mesh-proxy:" + clientId + ":" + proxyReq.requestId, proxyReq.payload);
+        });
+        return;
+    }
+    if (message.type === "mesh:proxy_response") {
+        var proxyRes = message;
+        log.meshProxy("received proxy_response via handler: %s", proxyRes.payload.type);
+        handleProxyResponse(proxyRes);
+        return;
+    }
+    if (message.type === "mesh:reconnect") {
+        var reconnectMsg = message;
+        reconnectPeer(reconnectMsg.nodeId);
+        setTimeout(function () {
+            broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+        }, 2000);
+        return;
+    }
+    if (message.type === "mesh:unpair") {
+        var unpairMsg = message;
+        var identity = loadOrCreateIdentity();
+        var peerWs = getPeerConnection(unpairMsg.nodeId);
+        if (peerWs) {
+            peerWs.send(JSON.stringify({ type: "mesh:unpaired", nodeId: identity.id }));
+        }
+        disconnectPeer(unpairMsg.nodeId);
+        var removed = removePeer(unpairMsg.nodeId);
+        if (removed) {
+            broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+        }
+        return;
+    }
+    if (message.type === "mesh:unpaired") {
+        var unpaired = message;
+        disconnectPeer(unpaired.nodeId);
+        var wasRemoved = removePeer(unpaired.nodeId);
+        if (wasRemoved) {
+            broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+        }
+        return;
+    }
+});

package/dist/server/handlers/notes.js

@@ -0,0 +1,36 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
+import { listNotes, createNote, updateNote, deleteNote } from "../features/sticky-notes.js";
+registerHandler("notes", function (clientId, message) {
+    if (message.type === "notes:list") {
+        var listMsg = message;
+        sendTo(clientId, { type: "notes:list_result", notes: listNotes(listMsg.projectSlug) });
+        return;
+    }
+    if (message.type === "notes:create") {
+        var createMsg = message;
+        var note = createNote(createMsg.content, createMsg.projectSlug);
+        broadcast({ type: "notes:created", note });
+        return;
+    }
+    if (message.type === "notes:update") {
+        var updateMsg = message;
+        var updated = updateNote(updateMsg.id, updateMsg.content);
+        if (!updated) {
+            sendTo(clientId, { type: "chat:error", message: "Note not found" });
+            return;
+        }
+        broadcast({ type: "notes:updated", note: updated });
+        return;
+    }
+    if (message.type === "notes:delete") {
+        var deleteMsg = message;
+        var deleted = deleteNote(deleteMsg.id);
+        if (!deleted) {
+            sendTo(clientId, { type: "chat:error", message: "Note not found" });
+            return;
+        }
+        broadcast({ type: "notes:deleted", id: deleteMsg.id });
+        return;
+    }
+});