@cryptiklemur/lattice 4.0.2 → 5.0.1

package/dist/server/mesh/connector.js

@@ -0,0 +1,355 @@
+import * as peersModule from "./peers.js";
+import { loadPeers } from "./peers.js";
+import { loadOrCreateIdentity } from "../identity.js";
+import { loadConfig } from "../config.js";
+import { listProjects } from "../project/registry.js";
+import { getProjectBySlug } from "../project/registry.js";
+import { handleSessionSync, handleSessionRequest } from "./session-sync.js";
+import { log } from "../logger.js";
+var connections = new Map();
+var lastKnownProjects = new Map();
+var connectedCallbacks = [];
+var disconnectedCallbacks = [];
+var messageCallbacks = [];
+var MIN_BACKOFF_MS = 1000;
+var MAX_BACKOFF_MS = 30000;
+var CONNECTION_TIMEOUT_MS = 10000;
+var CIRCUIT_BREAKER_THRESHOLD = 5;
+var CIRCUIT_BREAKER_COOLDOWN = 60000;
+var circuitBreakers = new Map();
+var RECONNECT_INTERVAL_MS = 15000;
+export function startMeshConnections() {
+    reconcilePeers();
+    setInterval(reconcilePeers, RECONNECT_INTERVAL_MS);
+}
+function reconcilePeers() {
+    var peers = loadPeers();
+    for (var i = 0; i < peers.length; i++) {
+        var peer = peers[i];
+        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 && isWebSocketOpen(existing.ws))
+            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]);
+        }
+    }
+}
+export function stopMeshConnections() {
+    for (var [, conn] of connections) {
+        conn.dead = true;
+        if (conn.retryTimer !== null) {
+            clearTimeout(conn.retryTimer);
+            conn.retryTimer = null;
+        }
+        conn.ws.close();
+    }
+    connections.clear();
+}
+export function connectToPeer(nodeId, address) {
+    if (connections.has(nodeId)) {
+        return;
+    }
+    var peers = loadPeers();
+    var peer = peers.find(function (p) { return p.id === nodeId; });
+    if (!peer) {
+        return;
+    }
+    var config = loadConfig();
+    var protocol = config.tls ? "wss" : "ws";
+    var url = address.includes(":")
+        ? protocol + "://" + address + "/ws"
+        : protocol + "://" + address + ":" + config.port + "/ws";
+    var conn = {
+        nodeId: nodeId,
+        ws: null,
+        backoffMs: MIN_BACKOFF_MS,
+        retryTimer: null,
+        dead: false,
+        projects: [],
+    };
+    connections.set(nodeId, conn);
+    openConnection(conn, url);
+}
+function openConnection(conn, url) {
+    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;
+                circuit.halfOpen = true;
+                openConnection(conn, url);
+            }, circuit.openUntil - Date.now());
+            return;
+        }
+        circuit.halfOpen = true;
+    }
+    log.meshConnect("opening WebSocket to %s", url);
+    var ws = new WebSocket(url);
+    conn.ws = ws;
+    var connectionTimer = setTimeout(function () {
+        if (!isWebSocketOpen(ws)) {
+            log.meshConnect("connection timeout for %s at %s", conn.nodeId.slice(0, 8), url);
+            ws.close();
+        }
+    }, CONNECTION_TIMEOUT_MS);
+    ws.addEventListener("open", function () {
+        clearTimeout(connectionTimer);
+        if (conn.dead) {
+            ws.close();
+            return;
+        }
+        circuitBreakers.delete(conn.nodeId);
+        conn.backoffMs = MIN_BACKOFF_MS;
+        var identity = loadOrCreateIdentity();
+        var config = loadConfig();
+        var projects = listProjects(identity.id);
+        var hello = {
+            type: "mesh:hello",
+            nodeId: identity.id,
+            name: config.name,
+            publicKey: identity.publicKey,
+            projects: projects.map(function (p) {
+                return { slug: p.slug, title: p.title };
+            }),
+        };
+        ws.send(JSON.stringify(hello));
+        log.mesh("Connected to peer: %s", conn.nodeId);
+        for (var i = 0; i < connectedCallbacks.length; i++) {
+            connectedCallbacks[i](conn.nodeId);
+        }
+    });
+    ws.addEventListener("message", function (event) {
+        if (conn.dead) {
+            return;
+        }
+        try {
+            var msg = JSON.parse(event.data);
+            if (msg.type === "mesh:hello") {
+                conn.projects = msg.projects;
+                if (msg.projects.length > 0) {
+                    lastKnownProjects.set(conn.nodeId, msg.projects);
+                }
+            }
+            else if (msg.type === "mesh:session_sync") {
+                handleSessionSync(conn.nodeId, msg);
+            }
+            else if (msg.type === "mesh:session_request") {
+                var reqMsg = msg;
+                var reqProject = getProjectBySlug(reqMsg.projectSlug);
+                if (reqProject) {
+                    handleSessionRequest(conn.nodeId, reqMsg, reqProject.path);
+                }
+            }
+            for (var i = 0; i < messageCallbacks.length; i++) {
+                messageCallbacks[i](conn.nodeId, msg);
+            }
+        }
+        catch {
+            log.mesh("Invalid message from peer: %s", conn.nodeId);
+        }
+    });
+    ws.addEventListener("close", function () {
+        clearTimeout(connectionTimer);
+        if (conn.dead) {
+            return;
+        }
+        var circuit = circuitBreakers.get(conn.nodeId);
+        if (!circuit) {
+            circuit = { failures: 0, openUntil: 0, halfOpen: false };
+            circuitBreakers.set(conn.nodeId, circuit);
+        }
+        circuit.failures++;
+        if (circuit.halfOpen) {
+            circuit.halfOpen = false;
+            circuit.openUntil = Date.now() + CIRCUIT_BREAKER_COOLDOWN;
+            log.mesh("Circuit breaker open for peer: %s (half-open attempt failed)", conn.nodeId);
+        }
+        else if (circuit.failures >= CIRCUIT_BREAKER_THRESHOLD) {
+            circuit.openUntil = Date.now() + CIRCUIT_BREAKER_COOLDOWN;
+            log.mesh("Circuit breaker open for peer: %s after %d consecutive failures", conn.nodeId, circuit.failures);
+        }
+        for (var i = 0; i < disconnectedCallbacks.length; i++) {
+            disconnectedCallbacks[i](conn.nodeId);
+        }
+        var delay = conn.backoffMs;
+        conn.backoffMs = Math.min(conn.backoffMs * 2, MAX_BACKOFF_MS);
+        conn.retryTimer = setTimeout(function () {
+            if (conn.dead) {
+                return;
+            }
+            conn.retryTimer = null;
+            openConnection(conn, url);
+        }, delay);
+    });
+    ws.addEventListener("error", function () {
+        log.mesh("WebSocket error for peer: %s", conn.nodeId);
+    });
+}
+export function getPeerConnection(nodeId) {
+    var conn = connections.get(nodeId);
+    if (!conn) {
+        return undefined;
+    }
+    if (!isWebSocketOpen(conn.ws)) {
+        return undefined;
+    }
+    return conn.ws;
+}
+export function registerInboundPeer(nodeId, ws, peerProjects) {
+    var existing = connections.get(nodeId);
+    if (existing && !existing.dead && isWebSocketOpen(existing.ws)) {
+        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;
+        if (existing.retryTimer !== null) {
+            clearTimeout(existing.retryTimer);
+        }
+    }
+    circuitBreakers.delete(nodeId);
+    var incomingProjects = peerProjects ?? [];
+    var conn = {
+        nodeId: nodeId,
+        ws: ws,
+        backoffMs: 1000,
+        retryTimer: null,
+        dead: false,
+        projects: incomingProjects,
+    };
+    if (incomingProjects.length > 0) {
+        lastKnownProjects.set(nodeId, incomingProjects);
+    }
+    connections.set(nodeId, conn);
+    var peers = loadPeers();
+    var peer = peers.find(function (p) { return p.id === nodeId; });
+    if (peer) {
+        var identity = loadOrCreateIdentity();
+        var config = loadConfig();
+        var projects = config.projects || [];
+        conn.projects = [];
+        ws.send(JSON.stringify({
+            type: "mesh:hello",
+            nodeId: identity.id,
+            name: config.name,
+            publicKey: identity.publicKey,
+            projects: projects.map(function (p) {
+                return { slug: p.slug, title: p.title };
+            }),
+        }));
+    }
+}
+export function disconnectPeer(nodeId) {
+    var existing = connections.get(nodeId);
+    if (existing) {
+        existing.dead = true;
+        if (existing.retryTimer !== null) {
+            clearTimeout(existing.retryTimer);
+            existing.retryTimer = null;
+        }
+        existing.ws.close();
+        connections.delete(nodeId);
+    }
+    circuitBreakers.delete(nodeId);
+}
+export function reconnectPeer(nodeId) {
+    var existing = connections.get(nodeId);
+    if (existing) {
+        existing.dead = true;
+        if (existing.retryTimer !== null) {
+            clearTimeout(existing.retryTimer);
+            existing.retryTimer = null;
+        }
+        existing.ws.close();
+        connections.delete(nodeId);
+    }
+    circuitBreakers.delete(nodeId);
+    var peers = loadPeers();
+    var peer = peers.find(function (p) { return p.id === nodeId; });
+    if (peer && peer.addresses && peer.addresses.length > 0) {
+        connectToPeer(nodeId, peer.addresses[0]);
+    }
+}
+export function getConnectedPeerIds() {
+    var ids = [];
+    for (var [nodeId, conn] of connections) {
+        if (isWebSocketOpen(conn.ws)) {
+            ids.push(nodeId);
+        }
+    }
+    return ids;
+}
+export function onPeerConnected(callback) {
+    connectedCallbacks.push(callback);
+}
+export function onPeerDisconnected(callback) {
+    disconnectedCallbacks.push(callback);
+}
+export function onPeerMessage(callback) {
+    messageCallbacks.push(callback);
+}
+function isWebSocketOpen(ws) {
+    return ws.readyState === WebSocket.OPEN || ws.readyState === 0;
+}
+export function getConnectedPeerProjects(nodeId) {
+    var conn = connections.get(nodeId);
+    if (!conn || !isWebSocketOpen(conn.ws))
+        return [];
+    return conn.projects;
+}
+export function getAllRemoteProjects(localNodeId) {
+    var allPeers = peersModule.loadPeers();
+    var connectedIds = new Set(getConnectedPeerIds());
+    var results = [];
+    for (var p = 0; p < allPeers.length; p++) {
+        var peer = allPeers[p];
+        var isOnline = connectedIds.has(peer.id);
+        var projects = [];
+        var conn = connections.get(peer.id);
+        if (conn && conn.projects.length > 0) {
+            projects = conn.projects;
+        }
+        else if (lastKnownProjects.has(peer.id)) {
+            projects = lastKnownProjects.get(peer.id);
+        }
+        for (var i = 0; i < projects.length; i++) {
+            results.push({
+                slug: projects[i].slug,
+                path: "",
+                title: projects[i].title,
+                nodeId: peer.id,
+                nodeName: peer.name,
+                isRemote: true,
+                online: isOnline,
+            });
+        }
+    }
+    return results;
+}
+export function findNodeForProject(projectSlug) {
+    for (var [nodeId, conn] of connections) {
+        if (!isWebSocketOpen(conn.ws)) {
+            continue;
+        }
+        for (var i = 0; i < conn.projects.length; i++) {
+            if (conn.projects[i].slug === projectSlug) {
+                return nodeId;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/server/mesh/crypto.js

@@ -0,0 +1,88 @@
+import { createSign, createVerify, randomBytes, createCipheriv, createDecipheriv, createHash, diffieHellman, generateKeyPairSync, createPublicKey, createPrivateKey } from "node:crypto";
+export function sign(privateKeyBase64, data) {
+    var privateKeyDer = Buffer.from(privateKeyBase64, "base64");
+    var key = createPrivateKey({ key: privateKeyDer, format: "der", type: "pkcs8" });
+    var signer = createSign("ed25519");
+    signer.update(data);
+    return signer.sign(key).toString("base64");
+}
+export function verify(publicKeyBase64, data, signatureBase64) {
+    try {
+        var publicKeyDer = Buffer.from(publicKeyBase64, "base64");
+        var key = createPublicKey({ key: publicKeyDer, format: "der", type: "spki" });
+        var verifier = createVerify("ed25519");
+        verifier.update(data);
+        return verifier.verify(key, Buffer.from(signatureBase64, "base64"));
+    }
+    catch {
+        return false;
+    }
+}
+export function generateChallenge() {
+    return randomBytes(32).toString("base64");
+}
+export function generateEphemeralKeys() {
+    var pair = generateKeyPairSync("x25519", {
+        publicKeyEncoding: { type: "spki", format: "der" },
+        privateKeyEncoding: { type: "pkcs8", format: "der" },
+    });
+    return {
+        publicKey: Buffer.from(pair.publicKey).toString("base64"),
+        privateKey: Buffer.from(pair.privateKey),
+    };
+}
+export function deriveSharedSecret(myPrivateKeyDer, theirPublicKeyBase64, nodeIdA, nodeIdB) {
+    var myKey = createPrivateKey({ key: myPrivateKeyDer, format: "der", type: "pkcs8" });
+    var theirKey = createPublicKey({ key: Buffer.from(theirPublicKeyBase64, "base64"), format: "der", type: "spki" });
+    var shared = diffieHellman({ privateKey: myKey, publicKey: theirKey });
+    var sortedIds = [nodeIdA, nodeIdB].sort().join(":");
+    var hash = createHash("sha256");
+    hash.update(shared);
+    hash.update(Buffer.from("lattice-mesh-v1:" + sortedIds));
+    return hash.digest();
+}
+export function encrypt(key, nonce, plaintext) {
+    var iv = Buffer.alloc(12);
+    iv.writeBigUInt64BE(BigInt(nonce), 4);
+    var cipher = createCipheriv("aes-256-gcm", key, iv);
+    var encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+    return {
+        ciphertext: encrypted.toString("base64"),
+        tag: cipher.getAuthTag().toString("base64"),
+    };
+}
+export function decrypt(key, nonce, ciphertext, tag) {
+    try {
+        var iv = Buffer.alloc(12);
+        iv.writeBigUInt64BE(BigInt(nonce), 4);
+        var decipher = createDecipheriv("aes-256-gcm", key, iv);
+        decipher.setAuthTag(Buffer.from(tag, "base64"));
+        var decrypted = Buffer.concat([decipher.update(Buffer.from(ciphertext, "base64")), decipher.final()]);
+        return decrypted.toString("utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+export function createSecureSession(sharedKey) {
+    return { sharedKey, sendNonce: 0, recvNonce: 0 };
+}
+export function encryptMessage(session, message) {
+    session.sendNonce++;
+    var result = encrypt(session.sharedKey, session.sendNonce, JSON.stringify(message));
+    return { type: "mesh:encrypted", nonce: session.sendNonce, ...result };
+}
+export function decryptMessage(session, nonce, ciphertext, tag) {
+    if (nonce <= session.recvNonce)
+        return null;
+    var plaintext = decrypt(session.sharedKey, nonce, ciphertext, tag);
+    if (!plaintext)
+        return null;
+    session.recvNonce = nonce;
+    try {
+        return JSON.parse(plaintext);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/mesh/discovery.js

@@ -0,0 +1,95 @@
+import BonjourImport from "bonjour-service";
+var Bonjour = (typeof BonjourImport === "function" ? BonjourImport : BonjourImport.default);
+var bonjour = null;
+var publishedService = null;
+var browser = null;
+var discoveredNodes = new Map();
+var discoveredCallbacks = [];
+var lostCallbacks = [];
+export function startDiscovery(nodeId, name, port) {
+    if (bonjour !== null) {
+        return;
+    }
+    bonjour = new Bonjour();
+    publishedService = bonjour.publish({
+        name: name,
+        type: "lattice",
+        port: port,
+        protocol: "tcp",
+        probe: false,
+        txt: {
+            nodeId: nodeId,
+            name: name,
+        },
+    });
+    console.log(`[discovery] Published _lattice._tcp as "${name}" on port ${port}`);
+    browser = bonjour.find({ type: "lattice", protocol: "tcp" }, function (service) {
+        var txt = service.txt;
+        if (!txt || !txt.nodeId) {
+            return;
+        }
+        if (txt.nodeId === nodeId) {
+            return;
+        }
+        var address = service.addresses && service.addresses.length > 0
+            ? service.addresses[0]
+            : (service.referer ? service.referer.address : "");
+        if (!address) {
+            return;
+        }
+        var node = {
+            nodeId: txt.nodeId,
+            name: txt.name || service.name,
+            address: address,
+            port: service.port,
+            discoveredAt: Date.now(),
+        };
+        discoveredNodes.set(node.nodeId, node);
+        console.log(`[discovery] Found node: ${node.name} (${node.nodeId}) at ${node.address}:${node.port}`);
+        for (var i = 0; i < discoveredCallbacks.length; i++) {
+            discoveredCallbacks[i](node);
+        }
+    });
+    browser.on("down", function (service) {
+        var txt = service.txt;
+        if (!txt || !txt.nodeId) {
+            return;
+        }
+        var lostId = txt.nodeId;
+        if (!discoveredNodes.has(lostId)) {
+            return;
+        }
+        discoveredNodes.delete(lostId);
+        console.log(`[discovery] Lost node: ${lostId}`);
+        for (var i = 0; i < lostCallbacks.length; i++) {
+            lostCallbacks[i](lostId);
+        }
+    });
+    browser.start();
+}
+export function stopDiscovery() {
+    if (browser !== null) {
+        browser.stop();
+        browser = null;
+    }
+    if (bonjour !== null) {
+        bonjour.unpublishAll(function () {
+            if (bonjour !== null) {
+                bonjour.destroy();
+                bonjour = null;
+            }
+        });
+        publishedService = null;
+    }
+    discoveredNodes.clear();
+    console.log("[discovery] Stopped");
+}
+export function getDiscoveredNodes() {
+    return Array.from(discoveredNodes.values());
+}
+export function onNodeDiscovered(callback) {
+    discoveredCallbacks.push(callback);
+}
+export function onNodeLost(callback) {
+    lostCallbacks.push(callback);
+}

package/dist/server/mesh/pairing.js

@@ -0,0 +1,104 @@
+import { randomBytes } from "node:crypto";
+var BASE62_CHARS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
+var CODE_LENGTH = 16;
+var PAIRING_TOKEN_TTL = 300000;
+var CLEANUP_INTERVAL = 60000;
+var pendingTokens = new Map();
+function base62Encode(buf) {
+    var n = BigInt("0x" + buf.toString("hex"));
+    var result = "";
+    var base = BigInt(BASE62_CHARS.length);
+    while (n > 0n) {
+        result = BASE62_CHARS[Number(n % base)] + result;
+        n = n / base;
+    }
+    while (result.length < CODE_LENGTH) {
+        result = BASE62_CHARS[0] + result;
+    }
+    return result;
+}
+function base62Decode(s) {
+    var n = 0n;
+    var base = BigInt(BASE62_CHARS.length);
+    for (var i = 0; i < s.length; i++) {
+        var idx = BASE62_CHARS.indexOf(s[i]);
+        if (idx < 0) {
+            throw new Error("Invalid base62 character: " + s[i]);
+        }
+        n = n * base + BigInt(idx);
+    }
+    var hex = n.toString(16);
+    if (hex.length % 2 !== 0) {
+        hex = "0" + hex;
+    }
+    return Buffer.from(hex, "hex");
+}
+function packPayload(address, port, token) {
+    var parts = address.split(".");
+    var buf = Buffer.alloc(4 + 2 + token.length);
+    for (var i = 0; i < 4; i++) {
+        buf[i] = parseInt(parts[i] || "0", 10);
+    }
+    buf.writeUInt16BE(port, 4);
+    token.copy(buf, 6);
+    return buf;
+}
+function unpackPayload(buf) {
+    if (buf.length < 8)
+        return null;
+    var address = buf[0] + "." + buf[1] + "." + buf[2] + "." + buf[3];
+    var port = buf.readUInt16BE(4);
+    var token = buf.subarray(6).toString("hex");
+    return { address, port, token };
+}
+function formatCode(raw) {
+    var chunks = [];
+    for (var i = 0; i < raw.length; i += 4) {
+        chunks.push(raw.slice(i, i + 4));
+    }
+    return "LTCE-" + chunks.join("-");
+}
+function stripCode(code) {
+    return code.replace(/^LTCE-/i, "").replace(/-/g, "");
+}
+export async function generateInviteCode(address, port) {
+    var tokenBuf = randomBytes(4);
+    var token = tokenBuf.toString("hex");
+    var payload = packPayload(address, port, tokenBuf);
+    var encoded = base62Encode(payload);
+    var code = formatCode(encoded);
+    pendingTokens.set(token, Date.now());
+    return { code, token, qrDataUrl: "" };
+}
+export function parseInviteCode(code) {
+    try {
+        var stripped = stripCode(code);
+        var decoded = base62Decode(stripped);
+        return unpackPayload(decoded);
+    }
+    catch {
+        return null;
+    }
+}
+export function validatePairingToken(token) {
+    var createdAt = pendingTokens.get(token);
+    if (createdAt === undefined) {
+        return false;
+    }
+    if (Date.now() - createdAt > PAIRING_TOKEN_TTL) {
+        pendingTokens.delete(token);
+        return false;
+    }
+    return true;
+}
+export function consumePairingToken(token) {
+    pendingTokens.delete(token);
+}
+setInterval(function () {
+    var now = Date.now();
+    pendingTokens.forEach(function (createdAt, token) {
+        if (now - createdAt > PAIRING_TOKEN_TTL) {
+            pendingTokens.delete(token);
+        }
+    });
+}, CLEANUP_INTERVAL);

package/dist/server/mesh/peers.js

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome } from "../config.js";
+function getPeersPath() {
+    return join(getLatticeHome(), "peers.json");
+}
+export function loadPeers() {
+    var path = getPeersPath();
+    if (!existsSync(path)) {
+        return [];
+    }
+    var raw = readFileSync(path, "utf-8");
+    return JSON.parse(raw);
+}
+export function savePeers(peers) {
+    var path = getPeersPath();
+    writeFileSync(path, JSON.stringify(peers, null, 2), "utf-8");
+}
+export function addPeer(peer) {
+    var peers = loadPeers();
+    var idx = peers.findIndex(function (p) { return p.id === peer.id; });
+    if (idx >= 0) {
+        peers[idx] = peer;
+    }
+    else {
+        var addrSet = new Set(peer.addresses);
+        var dupeIdx = peers.findIndex(function (p) {
+            return p.addresses.some(function (a) { return addrSet.has(a); });
+        });
+        if (dupeIdx >= 0) {
+            peers[dupeIdx] = peer;
+        }
+        else {
+            peers.push(peer);
+        }
+    }
+    savePeers(peers);
+}
+export function removePeer(nodeId) {
+    var peers = loadPeers();
+    var next = peers.filter(function (p) { return p.id !== nodeId; });
+    if (next.length === peers.length) {
+        return false;
+    }
+    savePeers(next);
+    return true;
+}
+export function getPeer(nodeId) {
+    var peers = loadPeers();
+    return peers.find(function (p) { return p.id === nodeId; });
+}
+export function isPaired(nodeId) {
+    return getPeer(nodeId) !== undefined;
+}