@cryptiklemur/lattice 4.0.2 → 5.0.1

package/src/server/mesh/pairing.ts

@@ -1,123 +0,0 @@
-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<string, number>();
-
-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;
-  }
-  while (result.length < CODE_LENGTH) {
-    result = BASE62_CHARS[0] + result;
-  }
-  return result;
-}
-
-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 packPayload(address: string, port: number, token: Buffer): Buffer {
-  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: Buffer): { address: string; port: number; token: string } | null {
-  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: string): string {
-  var chunks: string[] = [];
-  for (var i = 0; i < raw.length; i += 4) {
-    chunks.push(raw.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 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: string
-): { address: string; port: number; token: string } | null {
-  try {
-    var stripped = stripCode(code);
-    var decoded = base62Decode(stripped);
-    return unpackPayload(decoded);
-  } catch {
-    return null;
-  }
-}
-
-export function validatePairingToken(token: string): boolean {
-  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: string): void {
-  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/src/server/mesh/peers.ts

@@ -1,60 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { PeerInfo } from "#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 {
-    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: 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/src/server/mesh/proxy.ts

@@ -1,106 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { ClientMessage, MeshProxyRequestMessage, MeshProxyResponseMessage, ServerMessage } from "#shared";
-import { getPeerConnection } from "./connector";
-import { sendTo, broadcast, registerVirtualClient, removeVirtualClient } from "../ws/broadcast";
-import { routeMessage } from "../ws/router";
-import { log } from "../logger";
-
-var pendingRequests = new Map<string, string>();
-
-export function proxyToRemoteNode(nodeId: string, projectSlug: string, clientId: string, message: ClientMessage): void {
-  log.meshProxy("→ proxy %s to node %s for project %s", (message as any).type, nodeId.slice(0, 8), projectSlug);
-  var ws = getPeerConnection(nodeId);
-  if (!ws) {
-    log.meshProxy("  ✗ no connection to node %s", nodeId.slice(0, 8));
-    sendTo(clientId, { type: "chat:error", message: "Remote node is not connected" });
-    return;
-  }
-
-  var requestId = randomUUID();
-  pendingRequests.set(requestId, clientId);
-  log.meshProxy("  envelope requestId=%s", requestId.slice(0, 8));
-
-  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;
-  log.meshProxy("← proxy_request from %s: %s for %s (reqId=%s)", sourceNodeId.slice(0, 8), (msg.payload as any).type, msg.projectSlug, msg.requestId.slice(0, 8));
-
-  registerVirtualClient(proxyClientId, function (response: object) {
-    log.meshProxy("  → proxy_response %s back to %s", (response as any).type, sourceNodeId.slice(0, 8));
-    var ws = getPeerConnection(sourceNodeId);
-    if (!ws) {
-      console.warn("[mesh/proxy] Cannot send response, no connection to: " + sourceNodeId);
-      removeVirtualClient(proxyClientId);
-      return;
-    }
-
-    var envelope: MeshProxyResponseMessage = {
-      type: "mesh:proxy_response",
-      projectSlug: msg.projectSlug,
-      requestId: msg.requestId,
-      payload: response as ServerMessage,
-    };
-
-    ws.send(JSON.stringify(envelope));
-    removeVirtualClient(proxyClientId);
-  });
-
-  routeMessage(proxyClientId, msg.payload);
-}
-
-export function handleProxyResponse(msg: MeshProxyResponseMessage): void {
-  log.meshProxy("← proxy_response %s (reqId=%s)", (msg.payload as any).type, msg.requestId.slice(0, 8));
-  var clientId = pendingRequests.get(msg.requestId);
-  if (!clientId) {
-    log.meshProxy("  ✗ no pending request for %s", msg.requestId.slice(0, 8));
-    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/src/server/mesh/session-sync.ts

@@ -1,107 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, appendFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import type { MeshSessionSyncMessage, MeshSessionRequestMessage } from "#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));
-}

package/src/server/project/bookmarks.ts

@@ -1,83 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { randomBytes } from "node:crypto";
-import { getLatticeHome } from "../config";
-import type { MessageBookmark } from "#shared";
-
-var bookmarksFile = "";
-var bookmarks: MessageBookmark[] = [];
-
-function getBookmarksPath(): string {
-  if (!bookmarksFile) {
-    bookmarksFile = join(getLatticeHome(), "bookmarks.json");
-  }
-  return bookmarksFile;
-}
-
-export function loadBookmarks(): void {
-  var path = getBookmarksPath();
-  if (!existsSync(path)) {
-    bookmarks = [];
-    return;
-  }
-  try {
-    var raw = readFileSync(path, "utf-8");
-    bookmarks = JSON.parse(raw) as MessageBookmark[];
-  } catch (err) {
-    console.error("[bookmarks] Failed to load bookmarks:", err);
-    bookmarks = [];
-  }
-}
-
-function saveBookmarks(): void {
-  var path = getBookmarksPath();
-  var dir = join(path, "..");
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  var tmp = path + ".tmp";
-  try {
-    writeFileSync(tmp, JSON.stringify(bookmarks, null, 2));
-    renameSync(tmp, path);
-  } catch (err) {
-    console.error("[bookmarks] Failed to save bookmarks:", err);
-  }
-}
-
-export function listBookmarks(projectSlug?: string, sessionId?: string): MessageBookmark[] {
-  var result = bookmarks;
-  if (projectSlug) {
-    result = result.filter(function (b) { return b.projectSlug === projectSlug; });
-  }
-  if (sessionId) {
-    result = result.filter(function (b) { return b.sessionId === sessionId; });
-  }
-  return result.slice();
-}
-
-export function addBookmark(bookmark: Omit<MessageBookmark, "id" | "createdAt">): MessageBookmark {
-  var now = Date.now();
-  var entry: MessageBookmark = {
-    id: "bm_" + now + "_" + randomBytes(3).toString("hex"),
-    sessionId: bookmark.sessionId,
-    projectSlug: bookmark.projectSlug,
-    messageUuid: bookmark.messageUuid,
-    messageText: bookmark.messageText.slice(0, 100),
-    messageType: bookmark.messageType,
-    createdAt: now,
-  };
-  bookmarks.push(entry);
-  saveBookmarks();
-  return entry;
-}
-
-export function removeBookmark(id: string): boolean {
-  for (var i = 0; i < bookmarks.length; i++) {
-    if (bookmarks[i].id === id) {
-      bookmarks.splice(i, 1);
-      saveBookmarks();
-      return true;
-    }
-  }
-  return false;
-}