@cryptiklemur/lattice 4.0.2 → 5.0.0

package/src/server/update-checker.ts

@@ -1,147 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { log } from "./logger";
-
-var __dirname_local = dirname(fileURLToPath(import.meta.url));
-
-var PKG_NAME = "@cryptiklemur/lattice";
-var GITHUB_REPO = "cryptiklemur/lattice";
-var CHECK_INTERVAL_MS = 3600000;
-
-export type InstallMode = "binary" | "npm";
-
-export interface UpdateInfo {
-  currentVersion: string;
-  latestVersion: string | null;
-  updateAvailable: boolean;
-  lastCheckedAt: number;
-  releaseUrl: string | null;
-  installMode: InstallMode;
-}
-
-var cached: UpdateInfo | null = null;
-var checking = false;
-
-function getCurrentVersion(): string {
-  if (process.env.LATTICE_VERSION) return process.env.LATTICE_VERSION;
-  try {
-    var pkg = JSON.parse(readFileSync(join(__dirname_local, "../../package.json"), "utf-8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-function compareVersions(a: string, b: string): number {
-  if (!a || !b || typeof a !== "string" || typeof b !== "string") return 0;
-  var pa = a.replace(/^v/, "").split(".").map(Number);
-  var pb = b.replace(/^v/, "").split(".").map(Number);
-  for (var i = 0; i < 3; i++) {
-    var va = pa[i] || 0;
-    var vb = pb[i] || 0;
-    if (va !== vb) return va - vb;
-  }
-  return 0;
-}
-
-export function getInstallMode(): InstallMode {
-  return "npm";
-}
-
-async function checkGitHub(currentVersion: string): Promise<UpdateInfo> {
-  var res = await fetch("https://api.github.com/repos/" + GITHUB_REPO + "/releases/latest", {
-    headers: { "Accept": "application/vnd.github.v3+json" },
-    signal: AbortSignal.timeout(10000),
-  });
-
-  if (!res.ok) {
-    console.error("[lattice] GitHub update check failed: HTTP " + res.status);
-    return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "binary" };
-  }
-
-  var data = await res.json() as { tag_name?: string; html_url?: string };
-  var latestVersion = data.tag_name ? data.tag_name.replace(/^v/, "") : null;
-  var updateAvailable = latestVersion !== null && compareVersions(latestVersion, currentVersion) > 0;
-
-  return {
-    currentVersion,
-    latestVersion,
-    updateAvailable,
-    lastCheckedAt: Date.now(),
-    releaseUrl: updateAvailable ? (data.html_url ?? null) : null,
-    installMode: "binary",
-  };
-}
-
-async function checkNpm(currentVersion: string): Promise<UpdateInfo> {
-  var res = await fetch("https://registry.npmjs.org/" + PKG_NAME + "/latest", {
-    headers: { "Accept": "application/json" },
-    signal: AbortSignal.timeout(10000),
-  });
-
-  if (!res.ok) {
-    console.error("[lattice] npm update check failed: HTTP " + res.status);
-    return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "npm" };
-  }
-
-  var data = await res.json() as { version?: string };
-  var latestVersion = data.version ?? null;
-  var updateAvailable = latestVersion !== null && compareVersions(latestVersion, currentVersion) > 0;
-
-  return {
-    currentVersion,
-    latestVersion,
-    updateAvailable,
-    lastCheckedAt: Date.now(),
-    releaseUrl: updateAvailable ? "https://github.com/" + GITHUB_REPO + "/releases/tag/v" + latestVersion : null,
-    installMode: "npm",
-  };
-}
-
-export async function checkForUpdate(force: boolean = false): Promise<UpdateInfo> {
-  var currentVersion = getCurrentVersion();
-
-  if (!force && cached && Date.now() - cached.lastCheckedAt < CHECK_INTERVAL_MS) {
-    return cached;
-  }
-
-  if (checking) {
-    return cached ?? { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: 0, releaseUrl: null, installMode: getInstallMode() };
-  }
-
-  checking = true;
-  try {
-    cached = await checkNpm(currentVersion);
-
-    if (cached.updateAvailable) {
-      log.server("Update available: %s -> %s (%s)", currentVersion, cached.latestVersion, cached.installMode);
-    }
-    return cached;
-  } catch (err) {
-    console.error("[lattice] Update check error: " + (err instanceof Error ? err.message : String(err)));
-    cached = { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: getInstallMode() };
-    return cached;
-  } finally {
-    checking = false;
-  }
-}
-
-export function getCachedUpdateInfo(): UpdateInfo | null {
-  return cached;
-}
-
-export function getPackageName(): string {
-  return PKG_NAME;
-}
-
-export function getGitHubRepo(): string {
-  return GITHUB_REPO;
-}
-
-export function startPeriodicUpdateCheck(): void {
-  void checkForUpdate();
-  setInterval(function () {
-    void checkForUpdate();
-  }, CHECK_INTERVAL_MS);
-}

package/src/server/ws/broadcast.ts

@@ -1,61 +0,0 @@
-import type { WebSocket } from "ws";
-import { log } from "../logger";
-
-var clients = new Map<string, WebSocket>();
-var virtualSendHandlers = new Map<string, (message: object) => void>();
-
-export function registerVirtualClient(id: string, handler: (message: object) => void): void {
-  virtualSendHandlers.set(id, handler);
-}
-
-export function removeVirtualClient(id: string): void {
-  virtualSendHandlers.delete(id);
-}
-
-export function addClient(id: string, ws: WebSocket): void {
-  clients.set(id, ws);
-}
-
-export function removeClient(id: string): void {
-  clients.delete(id);
-}
-
-export function broadcast(message: object, excludeId?: string): void {
-  var text = JSON.stringify(message);
-  for (var [id, ws] of clients) {
-    if (id !== excludeId && ws.readyState === ws.OPEN) {
-      ws.send(text);
-    }
-  }
-}
-
-export function sendTo(id: string, message: object): void {
-  var ws = clients.get(id);
-  if (ws && ws.readyState === ws.OPEN) {
-    ws.send(JSON.stringify(message));
-    return;
-  }
-  var virtualHandler = virtualSendHandlers.get(id);
-  if (virtualHandler) {
-    virtualHandler(message);
-    return;
-  }
-  if (id.startsWith("mesh-proxy:")) {
-    log.broadcast("  ✗ sendTo %s but no virtual handler registered (msg=%s)", id.slice(0, 30), (message as any).type);
-  }
-}
-
-export function getClientWebSocket(id: string): WebSocket | undefined {
-  return clients.get(id);
-}
-
-export function getClientCount(): number {
-  return clients.size;
-}
-
-export function closeAllClients(): void {
-  for (var [, ws] of clients) {
-    ws.close();
-  }
-  clients.clear();
-}

package/src/server/ws/router.ts

@@ -1,123 +0,0 @@
-import type { ClientMessage } from "#shared";
-import { sendTo } from "./broadcast";
-import { log } from "../logger";
-
-var _registry: typeof import("../project/registry") | null = null;
-var _connector: typeof import("../mesh/connector") | null = null;
-var _proxy: typeof import("../mesh/proxy") | null = null;
-
-async function getRegistry(): Promise<typeof import("../project/registry")> {
-  if (!_registry) {
-    _registry = await import("../project/registry");
-  }
-  return _registry;
-}
-
-async function getConnector(): Promise<typeof import("../mesh/connector")> {
-  if (!_connector) {
-    _connector = await import("../mesh/connector");
-  }
-  return _connector;
-}
-
-async function getProxy(): Promise<typeof import("../mesh/proxy")> {
-  if (!_proxy) {
-    _proxy = await import("../mesh/proxy");
-  }
-  return _proxy;
-}
-
-type Handler = (clientId: string, message: ClientMessage) => void | Promise<void>;
-
-var handlers = new Map<string, Handler>();
-var clientRemoteNode = new Map<string, { nodeId: string; projectSlug: string }>();
-
-var PROXIED_PREFIXES = new Set(["session", "chat", "fs", "terminal"]);
-
-export function registerHandler(prefix: string, handler: Handler): void {
-  handlers.set(prefix, handler);
-}
-
-export function setClientRemoteNode(clientId: string, nodeId: string, projectSlug: string): void {
-  clientRemoteNode.set(clientId, { nodeId, projectSlug });
-}
-
-export function clearClientRemoteNode(clientId: string): void {
-  clientRemoteNode.delete(clientId);
-}
-
-export function getClientRemoteNode(clientId: string): { nodeId: string; projectSlug: string } | undefined {
-  return clientRemoteNode.get(clientId);
-}
-
-export async function routeMessage(clientId: string, message: ClientMessage): Promise<void> {
-  var prefix = message.type.split(":")[0];
-
-  log.router("→ %s from client %s (prefix=%s)", message.type, clientId.slice(0, 8), prefix);
-
-  if (PROXIED_PREFIXES.has(prefix)) {
-    var remote = clientRemoteNode.get(clientId);
-
-    var msgSlug = (message as any).projectSlug as string | undefined;
-
-    if (msgSlug) {
-      var localProject = await getLocalProject(msgSlug);
-      log.router("  slug=%s local=%s", msgSlug, localProject);
-      if (!localProject) {
-        var remoteEntry = await getRemoteNodeForProject(msgSlug);
-        if (remoteEntry) {
-          log.router("  → proxying to remote node %s for project %s", remoteEntry.nodeId.slice(0, 8), msgSlug);
-          setClientRemoteNode(clientId, remoteEntry.nodeId, msgSlug);
-          await proxyMessage(clientId, remoteEntry.nodeId, msgSlug, message);
-          return;
-        }
-        log.router("  ✗ no remote node found for slug %s", msgSlug);
-      } else if (message.type === "session:activate" || message.type === "session:list_request") {
-        clearClientRemoteNode(clientId);
-      }
-    } else if (remote) {
-      log.router("  → proxying via cached remote node %s", remote.nodeId.slice(0, 8));
-      await proxyMessage(clientId, remote.nodeId, remote.projectSlug, message);
-      return;
-    }
-  }
-
-  var handler = handlers.get(prefix);
-  if (handler) {
-    log.router("  → dispatching to %s handler", prefix);
-    try {
-      await handler(clientId, message);
-    } catch (err) {
-      var stack = err instanceof Error ? (err as Error).stack : String(err);
-      log.ws("Handler error for %s: %s", message.type, stack);
-      sendTo(clientId, { type: "chat:error", message: "Internal server error processing " + message.type });
-    }
-    return;
-  }
-  log.router("  ✗ no handler for %s", message.type);
-  sendTo(clientId, { type: "error", message: `Unknown message type: ${message.type}` });
-}
-
-async function getLocalProject(slug: string): Promise<boolean> {
-  var registry = await getRegistry();
-  return registry.getProjectBySlug(slug) !== undefined;
-}
-
-async function getRemoteNodeForProject(slug: string): Promise<{ nodeId: string } | undefined> {
-  var connector = await getConnector();
-  var nodeId = connector.findNodeForProject(slug);
-  if (nodeId) {
-    return { nodeId: nodeId };
-  }
-  return undefined;
-}
-
-async function proxyMessage(clientId: string, nodeId: string, projectSlug: string, message: ClientMessage): Promise<void> {
-  try {
-    var proxy = await getProxy();
-    proxy.proxyToRemoteNode(nodeId, projectSlug, clientId, message);
-  } catch (err) {
-    log.ws("Failed to proxy message: %O", err);
-    sendTo(clientId, { type: "chat:error", message: "Failed to proxy message to remote node" });
-  }
-}

package/src/server/ws/server.ts

@@ -1,2 +0,0 @@
-export { addClient, removeClient, broadcast, sendTo, getClientCount } from "./broadcast";
-export { registerHandler, routeMessage } from "./router";

package/src/shared/analytics.ts

@@ -1,40 +0,0 @@
-export interface AnalyticsPayload {
-  totalCost: number;
-  totalSessions: number;
-  totalTokens: { input: number; output: number; cacheRead: number; cacheCreation: number };
-  cacheHitRate: number;
-  avgSessionCost: number;
-  avgSessionDuration: number;
-
-  costOverTime: Array<{ date: string; total: number; opus: number; sonnet: number; haiku: number; other: number }>;
-  cumulativeCost: Array<{ date: string; total: number }>;
-  sessionsOverTime: Array<{ date: string; count: number }>;
-  tokensOverTime: Array<{ date: string; input: number; output: number; cacheRead: number }>;
-  cacheHitRateOverTime: Array<{ date: string; rate: number }>;
-
-  costDistribution: Array<{ bucket: string; count: number }>;
-  sessionBubbles: Array<{ id: string; title: string; cost: number; tokens: number; timestamp: number; project: string }>;
-
-  modelUsage: Array<{ model: string; sessions: number; cost: number; tokens: number; percentage: number }>;
-  projectBreakdown: Array<{ project: string; cost: number; sessions: number; tokens: number }>;
-  toolUsage: Array<{ tool: string; count: number; avgCost: number }>;
-
-  responseTimeData: Array<{ tokens: number; duration: number; model: string; sessionId: string }>;
-  contextUtilization: Array<{ messageIndex: number; contextPercent: number; sessionId: string; title: string }>;
-  tokenFlowSankey: { nodes: Array<{ name: string }>; links: Array<{ source: number; target: number; value: number }> };
-
-  activityCalendar: Array<{ date: string; count: number; tokens: number; cost: number }>;
-  hourlyHeatmap: Array<{ day: number; hour: number; count: number }>;
-  sessionTimeline: Array<{ id: string; title: string; project: string; start: number; end: number; cost: number }>;
-  dailySummaries: Array<{ date: string; sessions: number; cost: number; tokens: number; topTool: string; modelMix: Record<string, number> }>;
-
-  toolTreemap: Array<{ name: string; count: number; avgCost: number }>;
-  toolSunburst: Array<{ name: string; category: string; count: number }>;
-  permissionStats: { allowed: number; denied: number; alwaysAllowed: number };
-  projectRadar: Array<{ project: string; cost: number; sessions: number; avgDuration: number; toolDiversity: number; tokensPerSession: number }>;
-  sessionComplexity: Array<{ id: string; title: string; score: number; messages: number; tools: number; contextPercent: number }>;
-}
-
-export type AnalyticsPeriod = "24h" | "7d" | "30d" | "90d" | "all";
-export type AnalyticsScope = "global" | "project" | "session";
-export type AnalyticsSectionName = "summary" | "spending" | "usage" | "activity" | "projects";