@cryptiklemur/lattice 0.0.0

package/server/src/mesh/connector.ts

@@ -0,0 +1,209 @@
+import type { MeshMessage, MeshHelloMessage, MeshSessionSyncMessage, MeshSessionRequestMessage } from "@lattice/shared";
+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";
+
+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 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;
+
+export function startMeshConnections(): void {
+  var peers = loadPeers();
+  for (var i = 0; i < peers.length; i++) {
+    connectToPeer(peers[i].id, peers[i].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 port = config.port;
+  var protocol = config.tls ? "wss" : "ws";
+  var url = protocol + "://" + address + ":" + 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 ws = new WebSocket(url);
+  conn.ws = ws;
+
+  ws.addEventListener("open", function () {
+    if (conn.dead) {
+      ws.close();
+      return;
+    }
+
+    conn.backoffMs = MIN_BACKOFF_MS;
+
+    var identity = loadOrCreateIdentity();
+    var config = loadConfig();
+    var projects = listProjects(identity.id);
+
+    var hello: MeshHelloMessage = {
+      type: "mesh:hello",
+      nodeId: identity.id,
+      name: config.name,
+      projects: projects.map(function (p) {
+        return { slug: p.slug, title: p.title };
+      }),
+    };
+
+    ws.send(JSON.stringify(hello));
+
+    console.log("[mesh] Connected to peer: " + 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;
+      } 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 {
+      console.error("[mesh] Invalid message from peer: " + conn.nodeId);
+    }
+  });
+
+  ws.addEventListener("close", function () {
+    if (conn.dead) {
+      return;
+    }
+
+    console.log("[mesh] Disconnected from peer: " + conn.nodeId + ", reconnecting in " + conn.backoffMs + "ms");
+
+    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 () {
+    console.error("[mesh] WebSocket error for peer: " + conn.nodeId);
+  });
+}
+
+export function getPeerConnection(nodeId: string): WebSocket | undefined {
+  var conn = connections.get(nodeId);
+  if (!conn) {
+    return undefined;
+  }
+  if (conn.ws.readyState !== WebSocket.OPEN) {
+    return undefined;
+  }
+  return conn.ws;
+}
+
+export function getConnectedPeerIds(): string[] {
+  var ids: string[] = [];
+  for (var [nodeId, conn] of connections) {
+    if (conn.ws.readyState === WebSocket.OPEN) {
+      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);
+}
+
+export function findNodeForProject(projectSlug: string): string | undefined {
+  for (var [nodeId, conn] of connections) {
+    if (conn.ws.readyState !== WebSocket.OPEN) {
+      continue;
+    }
+    for (var i = 0; i < conn.projects.length; i++) {
+      if (conn.projects[i].slug === projectSlug) {
+        return nodeId;
+      }
+    }
+  }
+  return undefined;
+}

package/server/src/mesh/discovery.ts

@@ -0,0 +1,123 @@
+import Bonjour from "bonjour-service";
+import type { Service, Browser } from "bonjour-service";
+
+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",
+    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);
+}

package/server/src/mesh/pairing.ts

@@ -0,0 +1,94 @@
+import { randomBytes } from "node:crypto";
+import QRCode from "qrcode";
+
+var BASE62_CHARS = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
+
+var pendingTokens = new Set<string>();
+
+function base62Encode(buf: Buffer): string {
+  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;
+  }
+  return result || BASE62_CHARS[0];
+}
+
+function base62Decode(s: string): Buffer {
+  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 formatCode(raw: string): string {
+  var upper = raw.toUpperCase();
+  var chunks: string[] = [];
+  for (var i = 0; i < upper.length; i += 4) {
+    chunks.push(upper.slice(i, i + 4));
+  }
+  return "LTCE-" + chunks.join("-");
+}
+
+function stripCode(code: string): string {
+  return code.replace(/^LTCE-/i, "").replace(/-/g, "");
+}
+
+export async function generateInviteCode(
+  address: string,
+  port: number
+): Promise<{ code: string; token: string; qrDataUrl: string }> {
+  var token = randomBytes(8).toString("hex");
+  var payload = Buffer.from(address + ":" + port + ":" + token, "utf-8");
+  var encoded = base62Encode(payload);
+  var code = formatCode(encoded);
+
+  pendingTokens.add(token);
+
+  var qrDataUrl = await QRCode.toString(code, { type: "svg" });
+
+  return { code, token, qrDataUrl };
+}
+
+export function parseInviteCode(
+  code: string
+): { address: string; port: number; token: string } | null {
+  try {
+    var stripped = stripCode(code);
+    var decoded = base62Decode(stripped).toString("utf-8");
+    var parts = decoded.split(":");
+    if (parts.length < 3) {
+      return null;
+    }
+    var token = parts[parts.length - 1];
+    var portStr = parts[parts.length - 2];
+    var address = parts.slice(0, parts.length - 2).join(":");
+    var port = parseInt(portStr, 10);
+    if (isNaN(port)) {
+      return null;
+    }
+    return { address, port, token };
+  } catch {
+    return null;
+  }
+}
+
+export function validatePairingToken(token: string): boolean {
+  return pendingTokens.has(token);
+}
+
+export function consumePairingToken(token: string): void {
+  pendingTokens.delete(token);
+}

package/server/src/mesh/peers.ts

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { PeerInfo } from "@lattice/shared";
+import { getLatticeHome } from "../config";
+
+function getPeersPath(): string {
+  return join(getLatticeHome(), "peers.json");
+}
+
+export function loadPeers(): PeerInfo[] {
+  var path = getPeersPath();
+  if (!existsSync(path)) {
+    return [];
+  }
+  var raw = readFileSync(path, "utf-8");
+  return JSON.parse(raw) as PeerInfo[];
+}
+
+export function savePeers(peers: PeerInfo[]): void {
+  var path = getPeersPath();
+  writeFileSync(path, JSON.stringify(peers, null, 2), "utf-8");
+}
+
+export function addPeer(peer: PeerInfo): void {
+  var peers = loadPeers();
+  var idx = peers.findIndex(function (p) { return p.id === peer.id; });
+  if (idx >= 0) {
+    peers[idx] = peer;
+  } else {
+    peers.push(peer);
+  }
+  savePeers(peers);
+}
+
+export function removePeer(nodeId: string): boolean {
+  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: string): PeerInfo | undefined {
+  var peers = loadPeers();
+  return peers.find(function (p) { return p.id === nodeId; });
+}
+
+export function isPaired(nodeId: string): boolean {
+  return getPeer(nodeId) !== undefined;
+}

package/server/src/mesh/proxy.ts

@@ -0,0 +1,103 @@
+import { randomUUID } from "node:crypto";
+import type { ClientMessage, MeshProxyRequestMessage, MeshProxyResponseMessage, ServerMessage } from "@lattice/shared";
+import { getPeerConnection } from "./connector";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { routeMessage } from "../ws/router";
+
+var pendingRequests = new Map<string, string>();
+
+export function proxyToRemoteNode(nodeId: string, projectSlug: string, clientId: string, message: ClientMessage): void {
+  var ws = getPeerConnection(nodeId);
+  if (!ws) {
+    console.warn("[mesh/proxy] No connection to peer: " + nodeId);
+    sendTo(clientId, { type: "chat:error", message: "Remote node " + nodeId + " is not connected" });
+    return;
+  }
+
+  var requestId = randomUUID();
+  pendingRequests.set(requestId, clientId);
+
+  var envelope: MeshProxyRequestMessage = {
+    type: "mesh:proxy_request",
+    projectSlug: projectSlug,
+    requestId: requestId,
+    payload: message,
+  };
+
+  ws.send(JSON.stringify(envelope));
+}
+
+export function handleProxyRequest(sourceNodeId: string, msg: MeshProxyRequestMessage): void {
+  var proxyClientId = "mesh-proxy:" + sourceNodeId + ":" + msg.requestId;
+
+  var originalBroadcast = broadcast;
+  void originalBroadcast;
+
+  var interceptedSendTo = function (targetId: string, response: object): void {
+    if (targetId === proxyClientId) {
+      var ws = getPeerConnection(sourceNodeId);
+      if (!ws) {
+        console.warn("[mesh/proxy] Cannot send response, no connection to: " + sourceNodeId);
+        return;
+      }
+
+      var envelope: MeshProxyResponseMessage = {
+        type: "mesh:proxy_response",
+        projectSlug: msg.projectSlug,
+        requestId: msg.requestId,
+        payload: response as ServerMessage,
+      };
+
+      ws.send(JSON.stringify(envelope));
+    }
+  };
+
+  proxyRouteMessage(proxyClientId, msg.payload, interceptedSendTo);
+}
+
+export function handleProxyResponse(msg: MeshProxyResponseMessage): void {
+  var clientId = pendingRequests.get(msg.requestId);
+  if (!clientId) {
+    console.warn("[mesh/proxy] No pending request for id: " + msg.requestId);
+    return;
+  }
+
+  pendingRequests.delete(msg.requestId);
+  sendTo(clientId, msg.payload);
+}
+
+type SendToFn = (clientId: string, message: object) => void;
+
+var proxyHandlers = new Map<string, (clientId: string, message: ClientMessage, sendToFn: SendToFn) => void>();
+
+export function registerProxyAwareHandler(prefix: string, handler: (clientId: string, message: ClientMessage, sendToFn: SendToFn) => void): void {
+  proxyHandlers.set(prefix, handler);
+}
+
+function proxyRouteMessage(clientId: string, message: ClientMessage, sendToFn: SendToFn): void {
+  var prefix = message.type.split(":")[0];
+  var proxyHandler = proxyHandlers.get(prefix);
+  if (proxyHandler) {
+    proxyHandler(clientId, message, sendToFn);
+    return;
+  }
+  routeMessage(clientId, message);
+}
+
+export function getProxySendTo(requestId: string, sourceNodeId: string): ((msg: ServerMessage) => void) | undefined {
+  var clientId = pendingRequests.get(requestId);
+  if (clientId !== undefined) {
+    var resolvedClientId = clientId;
+    return function (msg: ServerMessage) {
+      sendTo(resolvedClientId, msg);
+    };
+  }
+
+  return function (msg: ServerMessage) {
+    var ws = getPeerConnection(sourceNodeId);
+    if (!ws) {
+      return;
+    }
+    ws.send(JSON.stringify(msg));
+  };
+}

package/server/src/mesh/session-sync.ts

@@ -0,0 +1,107 @@
+import { existsSync, mkdirSync, readFileSync, appendFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { MeshSessionSyncMessage, MeshSessionRequestMessage } from "@lattice/shared";
+import { getConnectedPeerIds, getPeerConnection } from "./connector";
+import { getLatticeHome } from "../config";
+
+var syncOffsets = new Map<string, number>();
+
+function getSyncKey(nodeId: string, sessionId: string): string {
+  return nodeId + ":" + sessionId;
+}
+
+function getRemoteSessionsDir(nodeId: string, projectSlug: string): string {
+  var dir = join(getLatticeHome(), "remote-sessions", nodeId, projectSlug);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function getSessionFilePath(projectPath: string, sessionId: string): string {
+  var hash = projectPath.replace(/\//g, "-");
+  return join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+}
+
+export function syncSessionToPeers(projectPath: string, projectSlug: string, sessionId: string): void {
+  var filePath = getSessionFilePath(projectPath, sessionId);
+  if (!existsSync(filePath)) {
+    return;
+  }
+
+  var content = readFileSync(filePath, "utf-8");
+  var peerIds = getConnectedPeerIds();
+
+  for (var i = 0; i < peerIds.length; i++) {
+    var nodeId = peerIds[i];
+    var key = getSyncKey(nodeId, sessionId);
+    var lastOffset = syncOffsets.get(key) || 0;
+
+    if (content.length <= lastOffset) {
+      continue;
+    }
+
+    var newContent = content.slice(lastOffset);
+    var newLines = newContent.split("\n").filter(function (l) { return l.trim().length > 0; });
+
+    if (newLines.length === 0) {
+      continue;
+    }
+
+    var ws = getPeerConnection(nodeId);
+    if (!ws) {
+      continue;
+    }
+
+    var msg: MeshSessionSyncMessage = {
+      type: "mesh:session_sync",
+      projectSlug,
+      sessionId,
+      lines: newLines,
+      offset: lastOffset,
+    };
+
+    ws.send(JSON.stringify(msg));
+    syncOffsets.set(key, content.length);
+  }
+}
+
+export function handleSessionSync(nodeId: string, msg: MeshSessionSyncMessage): void {
+  var dir = getRemoteSessionsDir(nodeId, msg.projectSlug);
+  var filePath = join(dir, msg.sessionId + ".jsonl");
+
+  for (var i = 0; i < msg.lines.length; i++) {
+    appendFileSync(filePath, msg.lines[i] + "\n", "utf-8");
+  }
+}
+
+export function handleSessionRequest(nodeId: string, msg: MeshSessionRequestMessage, projectPath: string): void {
+  var filePath = getSessionFilePath(projectPath, msg.sessionId);
+  if (!existsSync(filePath)) {
+    return;
+  }
+
+  var content = readFileSync(filePath, "utf-8");
+  var newContent = content.slice(msg.fromOffset);
+  var lines = newContent.split("\n").filter(function (l) { return l.trim().length > 0; });
+
+  if (lines.length === 0) {
+    return;
+  }
+
+  var ws = getPeerConnection(nodeId);
+  if (!ws) {
+    return;
+  }
+
+  var syncMsg: MeshSessionSyncMessage = {
+    type: "mesh:session_sync",
+    projectSlug: msg.projectSlug,
+    sessionId: msg.sessionId,
+    lines,
+    offset: msg.fromOffset,
+  };
+
+  ws.send(JSON.stringify(syncMsg));
+}