@cryptiklemur/lattice 4.0.1 → 5.0.0

package/src/server/mesh/connector.ts

@@ -1,419 +0,0 @@
-import type { MeshMessage, MeshHelloMessage, MeshSessionSyncMessage, MeshSessionRequestMessage } from "#shared";
-import * as peersModule from "./peers";
-import { loadPeers } from "./peers";
-import { loadOrCreateIdentity } from "../identity";
-import { loadConfig } from "../config";
-import { listProjects } from "../project/registry";
-import { getProjectBySlug } from "../project/registry";
-import { handleSessionSync, handleSessionRequest } from "./session-sync";
-import { log } from "../logger";
-
-interface PeerConnection {
-  nodeId: string;
-  ws: WebSocket;
-  backoffMs: number;
-  retryTimer: ReturnType<typeof setTimeout> | null;
-  dead: boolean;
-  projects: Array<{ slug: string; title: string }>;
-}
-
-var connections = new Map<string, PeerConnection>();
-var lastKnownProjects = new Map<string, Array<{ slug: string; title: string }>>();
-var connectedCallbacks: Array<(nodeId: string) => void> = [];
-var disconnectedCallbacks: Array<(nodeId: string) => void> = [];
-var messageCallbacks: Array<(nodeId: string, msg: MeshMessage) => void> = [];
-
-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;
-
-interface CircuitState {
-  failures: number;
-  openUntil: number;
-  halfOpen: boolean;
-}
-
-var circuitBreakers = new Map<string, CircuitState>();
-
-var RECONNECT_INTERVAL_MS = 15000;
-
-export function startMeshConnections(): void {
-  reconcilePeers();
-  setInterval(reconcilePeers, RECONNECT_INTERVAL_MS);
-}
-
-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) {
-      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(): void {
-  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: string, address: string): void {
-  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: PeerConnection = {
-    nodeId: nodeId,
-    ws: null as unknown as WebSocket,
-    backoffMs: MIN_BACKOFF_MS,
-    retryTimer: null,
-    dead: false,
-    projects: [],
-  };
-
-  connections.set(nodeId, conn);
-  openConnection(conn, url);
-}
-
-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;
-        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: MeshHelloMessage & { publicKey?: string } = {
-      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: MessageEvent) {
-    if (conn.dead) {
-      return;
-    }
-
-    try {
-      var msg = JSON.parse(event.data as string) as MeshMessage;
-
-      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 as MeshSessionSyncMessage);
-      } else if (msg.type === "mesh:session_request") {
-        var reqMsg = msg as MeshSessionRequestMessage;
-        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: string): WebSocket | undefined {
-  var conn = connections.get(nodeId);
-  if (!conn) {
-    return undefined;
-  }
-  if (!isWebSocketOpen(conn.ws)) {
-    return undefined;
-  }
-  return conn.ws;
-}
-
-export function registerInboundPeer(nodeId: string, ws: { send: (data: string) => void; readyState: number }, peerProjects?: Array<{ slug: string; title: string }>): void {
-  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: PeerConnection = {
-    nodeId: nodeId,
-    ws: ws as WebSocket,
-    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: { slug: string; title: string }) {
-        return { slug: p.slug, title: p.title };
-      }),
-    }));
-  }
-}
-
-export function disconnectPeer(nodeId: string): void {
-  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: string): void {
-  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(): string[] {
-  var ids: string[] = [];
-  for (var [nodeId, conn] of connections) {
-    if (isWebSocketOpen(conn.ws)) {
-      ids.push(nodeId);
-    }
-  }
-  return ids;
-}
-
-export function onPeerConnected(callback: (nodeId: string) => void): void {
-  connectedCallbacks.push(callback);
-}
-
-export function onPeerDisconnected(callback: (nodeId: string) => void): void {
-  disconnectedCallbacks.push(callback);
-}
-
-export function onPeerMessage(callback: (nodeId: string, msg: MeshMessage) => void): void {
-  messageCallbacks.push(callback);
-}
-
-function isWebSocketOpen(ws: { readyState: number }): boolean {
-  return ws.readyState === WebSocket.OPEN || ws.readyState === 0;
-}
-
-export function getConnectedPeerProjects(nodeId: string): Array<{ slug: string; title: string }> {
-  var conn = connections.get(nodeId);
-  if (!conn || !isWebSocketOpen(conn.ws)) return [];
-  return conn.projects;
-}
-
-export function getAllRemoteProjects(localNodeId: string): Array<{ slug: string; path: string; title: string; nodeId: string; nodeName: string; isRemote: boolean; online: boolean }> {
-  var allPeers = peersModule.loadPeers();
-  var connectedIds = new Set(getConnectedPeerIds());
-  var results: Array<{ slug: string; path: string; title: string; nodeId: string; nodeName: string; isRemote: boolean; online: boolean }> = [];
-
-  for (var p = 0; p < allPeers.length; p++) {
-    var peer = allPeers[p];
-    var isOnline = connectedIds.has(peer.id);
-    var projects: Array<{ slug: string; title: string }> = [];
-
-    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: string): string | undefined {
-  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/src/server/mesh/crypto.ts

@@ -1,106 +0,0 @@
-import { createSign, createVerify, randomBytes, createCipheriv, createDecipheriv, createHash, diffieHellman, generateKeyPairSync, createPublicKey, createPrivateKey } from "node:crypto";
-
-export function sign(privateKeyBase64: string, data: Buffer): string {
-  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: string, data: Buffer, signatureBase64: string): boolean {
-  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(): string {
-  return randomBytes(32).toString("base64");
-}
-
-export interface EphemeralKeys {
-  publicKey: string;
-  privateKey: Buffer;
-}
-
-export function generateEphemeralKeys(): EphemeralKeys {
-  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: Buffer, theirPublicKeyBase64: string, nodeIdA: string, nodeIdB: string): Buffer {
-  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: Buffer, nonce: number, plaintext: string): { ciphertext: string; tag: string } {
-  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: Buffer, nonce: number, ciphertext: string, tag: string): string | null {
-  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 interface SecureSession {
-  sharedKey: Buffer;
-  sendNonce: number;
-  recvNonce: number;
-}
-
-export function createSecureSession(sharedKey: Buffer): SecureSession {
-  return { sharedKey, sendNonce: 0, recvNonce: 0 };
-}
-
-export function encryptMessage(session: SecureSession, message: object): { type: "mesh:encrypted"; nonce: number; ciphertext: string; tag: string } {
-  session.sendNonce++;
-  var result = encrypt(session.sharedKey, session.sendNonce, JSON.stringify(message));
-  return { type: "mesh:encrypted", nonce: session.sendNonce, ...result };
-}
-
-export function decryptMessage(session: SecureSession, nonce: number, ciphertext: string, tag: string): object | null {
-  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/src/server/mesh/discovery.ts

@@ -1,126 +0,0 @@
-import BonjourImport from "bonjour-service";
-import type { Service, Browser } from "bonjour-service";
-
-var Bonjour = (typeof BonjourImport === "function" ? BonjourImport : (BonjourImport as any).default) as typeof BonjourImport;
-
-export interface DiscoveredNode {
-  nodeId: string;
-  name: string;
-  address: string;
-  port: number;
-  discoveredAt: number;
-}
-
-var bonjour: InstanceType<typeof Bonjour> | null = null;
-var publishedService: Service | null = null;
-var browser: Browser | null = null;
-var discoveredNodes: Map<string, DiscoveredNode> = new Map();
-var discoveredCallbacks: Array<(node: DiscoveredNode) => void> = [];
-var lostCallbacks: Array<(nodeId: string) => void> = [];
-
-export function startDiscovery(nodeId: string, name: string, port: number): void {
-  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: Service) {
-      var txt = service.txt as Record<string, string> | undefined;
-      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: DiscoveredNode = {
-        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: Service) {
-    var txt = service.txt as Record<string, string> | undefined;
-    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(): void {
-  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(): DiscoveredNode[] {
-  return Array.from(discoveredNodes.values());
-}
-
-export function onNodeDiscovered(callback: (node: DiscoveredNode) => void): void {
-  discoveredCallbacks.push(callback);
-}
-
-export function onNodeLost(callback: (nodeId: string) => void): void {
-  lostCallbacks.push(callback);
-}