@cryptiklemur/lattice 1.46.7 → 2.0.0

package/src/server/push.ts

@@ -0,0 +1,121 @@
+import webpush from "web-push";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome } from "./config";
+import { log } from "./logger";
+
+interface VapidKeys {
+  publicKey: string;
+  privateKey: string;
+}
+
+interface PushSubscription {
+  endpoint: string;
+  keys: {
+    p256dh: string;
+    auth: string;
+  };
+}
+
+var vapidKeys: VapidKeys | null = null;
+var subscriptions = new Map<string, PushSubscription>();
+
+function getVapidPath(): string {
+  return join(getLatticeHome(), "vapid.json");
+}
+
+function getSubscriptionsPath(): string {
+  return join(getLatticeHome(), "push-subs.json");
+}
+
+function ensureVapidKeys(): VapidKeys {
+  if (vapidKeys) return vapidKeys;
+
+  var vapidPath = getVapidPath();
+  if (existsSync(vapidPath)) {
+    try {
+      vapidKeys = JSON.parse(readFileSync(vapidPath, "utf-8"));
+      if (vapidKeys) return vapidKeys;
+    } catch {}
+  }
+
+  var generated = webpush.generateVAPIDKeys();
+  vapidKeys = {
+    publicKey: generated.publicKey,
+    privateKey: generated.privateKey,
+  };
+
+  var dir = getLatticeHome();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(vapidPath, JSON.stringify(vapidKeys, null, 2), "utf-8");
+  log.server("Generated VAPID keys for push notifications");
+  return vapidKeys;
+}
+
+function loadSubscriptions(): void {
+  var subsPath = getSubscriptionsPath();
+  if (!existsSync(subsPath)) return;
+  try {
+    var data = JSON.parse(readFileSync(subsPath, "utf-8")) as PushSubscription[];
+    for (var i = 0; i < data.length; i++) {
+      subscriptions.set(data[i].endpoint, data[i]);
+    }
+  } catch {}
+}
+
+function saveSubscriptions(): void {
+  var arr: PushSubscription[] = [];
+  subscriptions.forEach(function (sub) {
+    arr.push(sub);
+  });
+  writeFileSync(getSubscriptionsPath(), JSON.stringify(arr), "utf-8");
+}
+
+export function initPush(): void {
+  var keys = ensureVapidKeys();
+  webpush.setVapidDetails(
+    "mailto:lattice@localhost",
+    keys.publicKey,
+    keys.privateKey,
+  );
+  loadSubscriptions();
+  log.server("Push notifications ready (%d subscription(s))", subscriptions.size);
+}
+
+export function getVapidPublicKey(): string {
+  return ensureVapidKeys().publicKey;
+}
+
+export function addPushSubscription(sub: PushSubscription): void {
+  subscriptions.set(sub.endpoint, sub);
+  saveSubscriptions();
+}
+
+export function removePushSubscription(endpoint: string): void {
+  subscriptions.delete(endpoint);
+  saveSubscriptions();
+}
+
+export interface PushPayload {
+  type: "done" | "permission_request" | "elicitation" | "error";
+  title: string;
+  body: string;
+  sessionId?: string;
+  projectSlug?: string;
+}
+
+export function sendPush(payload: PushPayload): void {
+  if (subscriptions.size === 0) return;
+
+  var json = JSON.stringify(payload);
+  subscriptions.forEach(function (sub, endpoint) {
+    webpush.sendNotification(sub, json).catch(function (err: { statusCode?: number }) {
+      if (err.statusCode === 410 || err.statusCode === 404 || err.statusCode === 403) {
+        subscriptions.delete(endpoint);
+        saveSubscriptions();
+      }
+    });
+  });
+}

package/src/server/runtime.ts

@@ -0,0 +1 @@
+export var IS_NPM = true;

package/src/server/tui.ts

@@ -0,0 +1,103 @@
+import * as p from "@clack/prompts";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome, loadConfig, saveConfig } from "./config";
+import type { LatticeConfig } from "@lattice/shared";
+import { DEFAULT_PORT } from "@lattice/shared";
+
+var BANNER = `
+  \x1b[36m██╗\x1b[0m      \x1b[36m█████╗\x1b[0m \x1b[36m████████╗████████╗██╗\x1b[0m \x1b[36m██████╗\x1b[0m \x1b[36m███████╗\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m██╔══██╗\x1b[0m\x1b[2m╚══\x1b[0m\x1b[36m██\x1b[0m\x1b[2m╔══╝╚══\x1b[0m\x1b[36m██\x1b[0m\x1b[2m╔══╝\x1b[0m\x1b[36m██║\x1b[0m\x1b[36m██╔════╝\x1b[0m\x1b[36m██╔════╝\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m███████║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║██║\x1b[0m     \x1b[36m█████╗\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m██╔══██║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║██║\x1b[0m     \x1b[36m██╔══╝\x1b[0m
+  \x1b[36m███████╗██║  ██║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║\x1b[0m\x1b[2m╚\x1b[0m\x1b[36m██████╗███████╗\x1b[0m
+  \x1b[2m╚══════╝╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚═╝ ╚═════╝╚══════╝\x1b[0m
+`;
+
+export function printBanner(): void {
+  console.log(BANNER);
+}
+
+export function printStatus(config: LatticeConfig, version: string, projectCount: number, sessionCount: number): void {
+  var protocol = config.tls ? "https" : "http";
+  var url = protocol + "://localhost:" + config.port;
+
+  console.log("");
+  p.note(
+    "lattice v" + version + " — " + url + "\n" +
+    projectCount + " project" + (projectCount !== 1 ? "s" : "") +
+    " · " + sessionCount + " session" + (sessionCount !== 1 ? "s" : "") + "\n" +
+    "Press Ctrl+C to stop",
+    "Running"
+  );
+  console.log("");
+}
+
+export async function printQrCode(url: string): Promise<void> {
+  try {
+    var qrcode = await import("qrcode");
+    var qr = await (qrcode as any).toString(url, {
+      type: "terminal",
+      small: true,
+    });
+    console.log(qr);
+    console.log("  \x1b[2m" + url + "\x1b[0m");
+    console.log("");
+  } catch {
+    console.log("  " + url);
+    console.log("");
+  }
+}
+
+export async function runOnboarding(): Promise<{ port: number; passphrase: string | null }> {
+  var configPath = join(getLatticeHome(), "config.json");
+  var isFirstRun = !existsSync(configPath);
+
+  if (!isFirstRun) {
+    var config = loadConfig();
+    return { port: config.port, passphrase: null };
+  }
+
+  printBanner();
+
+  p.intro("Welcome to Lattice");
+
+  p.note(
+    "Anyone with the URL gets full Claude Code access to this machine.\n" +
+    "Use a private network (Tailscale, VPN) or set a passphrase.",
+    "Security"
+  );
+
+  var portResult = await p.text({
+    message: "Port",
+    placeholder: String(DEFAULT_PORT),
+    defaultValue: String(DEFAULT_PORT),
+    validate: function (val: string | undefined) {
+      var n = parseInt(val || "", 10);
+      if (isNaN(n) || n < 1 || n > 65535) return "Enter a valid port (1-65535)";
+      return undefined;
+    },
+  });
+  if (p.isCancel(portResult)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+  var port = parseInt(portResult as string, 10);
+
+  var passphraseResult = await p.password({
+    message: "Passphrase (optional, press Enter to skip)",
+  });
+  if (p.isCancel(passphraseResult)) {
+    p.cancel("Setup cancelled");
+    process.exit(0);
+  }
+  var passphrase = (passphraseResult as string) || null;
+
+  p.outro("Setup complete");
+
+  var config = loadConfig();
+  config.port = port;
+  saveConfig(config);
+
+  return { port, passphrase };
+}

package/{server/src → src/server}/update-checker.ts

@@ -1,7 +1,9 @@
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { log } from "./logger";
-import { IS_COMPILED } from "./runtime";
+
+var __dirname_local = dirname(fileURLToPath(import.meta.url));
 
 var PKG_NAME = "@cryptiklemur/lattice";
 var GITHUB_REPO = "cryptiklemur/lattice";
@@ -24,7 +26,7 @@ var checking = false;
 function getCurrentVersion(): string {
   if (process.env.LATTICE_VERSION) return process.env.LATTICE_VERSION;
   try {
-    var pkg = JSON.parse(readFileSync(join(import.meta.dir, "../../package.json"), "utf-8"));
+    var pkg = JSON.parse(readFileSync(join(__dirname_local, "../../package.json"), "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -44,7 +46,7 @@ function compareVersions(a: string, b: string): number {
 }
 
 export function getInstallMode(): InstallMode {
-  return IS_COMPILED ? "binary" : "npm";
+  return "npm";
 }
 
 async function checkGitHub(currentVersion: string): Promise<UpdateInfo> {
@@ -54,7 +56,7 @@ async function checkGitHub(currentVersion: string): Promise<UpdateInfo> {
   });
 
   if (!res.ok) {
-    log.server("GitHub update check failed: HTTP %d", res.status);
+    console.error("[lattice] GitHub update check failed: HTTP " + res.status);
     return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "binary" };
   }
 
@@ -79,7 +81,7 @@ async function checkNpm(currentVersion: string): Promise<UpdateInfo> {
   });
 
   if (!res.ok) {
-    log.server("npm update check failed: HTTP %d", res.status);
+    console.error("[lattice] npm update check failed: HTTP " + res.status);
     return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "npm" };
   }
 
@@ -110,16 +112,14 @@ export async function checkForUpdate(force: boolean = false): Promise<UpdateInfo
 
   checking = true;
   try {
-    cached = IS_COMPILED
-      ? await checkGitHub(currentVersion)
-      : await checkNpm(currentVersion);
+    cached = await checkNpm(currentVersion);
 
     if (cached.updateAvailable) {
       log.server("Update available: %s -> %s (%s)", currentVersion, cached.latestVersion, cached.installMode);
     }
     return cached;
   } catch (err) {
-    log.server("Update check error: %s", err instanceof Error ? err.message : String(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 {

package/{server/src → src/server}/ws/broadcast.ts

@@ -1,6 +1,7 @@
-import type { ServerWebSocket } from "bun";
+import type { WebSocket } from "ws";
+import { log } from "../logger";
 
-var clients = new Map<string, ServerWebSocket<{ id: string }>>();
+var clients = new Map<string, WebSocket>();
 var virtualSendHandlers = new Map<string, (message: object) => void>();
 
 export function registerVirtualClient(id: string, handler: (message: object) => void): void {
@@ -11,8 +12,8 @@ export function removeVirtualClient(id: string): void {
   virtualSendHandlers.delete(id);
 }
 
-export function addClient(ws: ServerWebSocket<{ id: string }>): void {
-  clients.set(ws.data.id, ws);
+export function addClient(id: string, ws: WebSocket): void {
+  clients.set(id, ws);
 }
 
 export function removeClient(id: string): void {
@@ -22,7 +23,7 @@ export function removeClient(id: string): void {
 export function broadcast(message: object, excludeId?: string): void {
   var text = JSON.stringify(message);
   for (var [id, ws] of clients) {
-    if (id !== excludeId) {
+    if (id !== excludeId && ws.readyState === ws.OPEN) {
       ws.send(text);
     }
   }
@@ -30,7 +31,7 @@ export function broadcast(message: object, excludeId?: string): void {
 
 export function sendTo(id: string, message: object): void {
   var ws = clients.get(id);
-  if (ws) {
+  if (ws && ws.readyState === ws.OPEN) {
     ws.send(JSON.stringify(message));
     return;
   }
@@ -40,12 +41,11 @@ export function sendTo(id: string, message: object): void {
     return;
   }
   if (id.startsWith("mesh-proxy:")) {
-    var { log } = require("../logger");
     log.broadcast("  ✗ sendTo %s but no virtual handler registered (msg=%s)", id.slice(0, 30), (message as any).type);
   }
 }
 
-export function getClientWebSocket(id: string): ServerWebSocket<{ id: string }> | undefined {
+export function getClientWebSocket(id: string): WebSocket | undefined {
   return clients.get(id);
 }
 

package/{server/src → src/server}/ws/router.ts

@@ -6,23 +6,23 @@ var _registry: typeof import("../project/registry") | null = null;
 var _connector: typeof import("../mesh/connector") | null = null;
 var _proxy: typeof import("../mesh/proxy") | null = null;
 
-function getRegistry(): typeof import("../project/registry") {
+async function getRegistry(): Promise<typeof import("../project/registry")> {
   if (!_registry) {
-    _registry = require("../project/registry") as typeof import("../project/registry");
+    _registry = await import("../project/registry");
   }
   return _registry;
 }
 
-function getConnector(): typeof import("../mesh/connector") {
+async function getConnector(): Promise<typeof import("../mesh/connector")> {
   if (!_connector) {
-    _connector = require("../mesh/connector") as typeof import("../mesh/connector");
+    _connector = await import("../mesh/connector");
   }
   return _connector;
 }
 
-function getProxy(): typeof import("../mesh/proxy") {
+async function getProxy(): Promise<typeof import("../mesh/proxy")> {
   if (!_proxy) {
-    _proxy = require("../mesh/proxy") as typeof import("../mesh/proxy");
+    _proxy = await import("../mesh/proxy");
   }
   return _proxy;
 }
@@ -50,7 +50,7 @@ export function getClientRemoteNode(clientId: string): { nodeId: string; project
   return clientRemoteNode.get(clientId);
 }
 
-export function routeMessage(clientId: string, message: ClientMessage): void {
+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);
@@ -61,14 +61,14 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
     var msgSlug = (message as any).projectSlug as string | undefined;
 
     if (msgSlug) {
-      var localProject = getLocalProject(msgSlug);
+      var localProject = await getLocalProject(msgSlug);
       log.router("  slug=%s local=%s", msgSlug, localProject);
       if (!localProject) {
-        var remoteEntry = getRemoteNodeForProject(msgSlug);
+        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);
-          proxyMessage(clientId, remoteEntry.nodeId, msgSlug, message);
+          await proxyMessage(clientId, remoteEntry.nodeId, msgSlug, message);
           return;
         }
         log.router("  ✗ no remote node found for slug %s", msgSlug);
@@ -77,7 +77,7 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
       }
     } else if (remote) {
       log.router("  → proxying via cached remote node %s", remote.nodeId.slice(0, 8));
-      proxyMessage(clientId, remote.nodeId, remote.projectSlug, message);
+      await proxyMessage(clientId, remote.nodeId, remote.projectSlug, message);
       return;
     }
   }
@@ -86,14 +86,7 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
   if (handler) {
     log.router("  → dispatching to %s handler", prefix);
     try {
-      var result = handler(clientId, message);
-      if (result && typeof result.then === "function") {
-        result.then(undefined, function (err: unknown) {
-          var stack = err instanceof Error ? err.stack : String(err);
-          log.ws("Async handler error for %s: %s", message.type, stack);
-          sendTo(clientId, { type: "chat:error", message: "Internal server error processing " + message.type });
-        });
-      }
+      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);
@@ -105,21 +98,24 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
   sendTo(clientId, { type: "error", message: `Unknown message type: ${message.type}` });
 }
 
-function getLocalProject(slug: string): boolean {
-  return getRegistry().getProjectBySlug(slug) !== undefined;
+async function getLocalProject(slug: string): Promise<boolean> {
+  var registry = await getRegistry();
+  return registry.getProjectBySlug(slug) !== undefined;
 }
 
-function getRemoteNodeForProject(slug: string): { nodeId: string } | undefined {
-  var nodeId = getConnector().findNodeForProject(slug);
+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;
 }
 
-function proxyMessage(clientId: string, nodeId: string, projectSlug: string, message: ClientMessage): void {
+async function proxyMessage(clientId: string, nodeId: string, projectSlug: string, message: ClientMessage): Promise<void> {
   try {
-    getProxy().proxyToRemoteNode(nodeId, projectSlug, clientId, message);
+    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/{shared/src → src/shared}/analytics.ts

@@ -37,3 +37,4 @@ export interface AnalyticsPayload {
 
 export type AnalyticsPeriod = "24h" | "7d" | "30d" | "90d" | "all";
 export type AnalyticsScope = "global" | "project" | "session";
+export type AnalyticsSectionName = "summary" | "spending" | "usage" | "activity" | "projects";

package/{shared/src → src/shared}/constants.ts

@@ -1,4 +1,5 @@
 export var DEFAULT_PORT = 7654;
+export var DEFAULT_DEV_PORT = 17654;
 export var PROTOCOL_VERSION = 1;
 export var MDNS_SERVICE_TYPE = "_lattice._tcp";
 export var LATTICE_HOME_DIR = ".lattice";