@cryptiklemur/lattice 4.0.2 → 5.0.1

package/src/server/project/terminal.ts

@@ -1,111 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
-import type { ChildProcess } from "node:child_process";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
-
-var __dirname_local = dirname(fileURLToPath(import.meta.url));
-
-interface TerminalWorker {
-  process: ChildProcess;
-  send: (msg: object) => void;
-}
-
-var terminals = new Map<string, TerminalWorker>();
-
-var WORKER_PATH = join(__dirname_local, "pty-worker.cjs");
-
-var NODE_MODULES_PATH = (function () {
-  try {
-    var resolved = require.resolve("node-pty");
-    var parts = resolved.split("/node_modules/");
-    parts.pop();
-    return parts.join("/node_modules/") + "/node_modules";
-  } catch {
-    return join(__dirname_local, "..", "..", "..", "node_modules");
-  }
-})();
-
-export function createTerminal(
-  cwd: string,
-  onData: (data: string) => void,
-  onExit: (code: number) => void,
-): string {
-  var termId = randomUUID();
-
-  var child = spawn("node", [WORKER_PATH], {
-    stdio: ["pipe", "pipe", "ignore"],
-    cwd: cwd,
-    env: { ...process.env, NODE_PATH: NODE_MODULES_PATH },
-  });
-
-  var buffer = "";
-
-  child.stdout!.setEncoding("utf-8");
-  child.stdout!.on("data", function (chunk: string) {
-    buffer += chunk;
-    var lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (var i = 0; i < lines.length; i++) {
-      if (!lines[i].trim()) continue;
-      try {
-        var msg = JSON.parse(lines[i]);
-        if (msg.type === "data") {
-          onData(msg.data);
-        } else if (msg.type === "exit") {
-          terminals.delete(termId);
-          onExit(msg.code ?? 0);
-        }
-      } catch {
-        // ignore parse errors
-      }
-    }
-  });
-
-  child.on("exit", function () {
-    if (terminals.has(termId)) {
-      terminals.delete(termId);
-      onExit(0);
-    }
-  });
-
-  function sendMsg(msg: object) {
-    if (child.stdin && !child.stdin.destroyed) {
-      child.stdin.write(JSON.stringify(msg) + "\n");
-    }
-  }
-
-  terminals.set(termId, { process: child, send: sendMsg });
-
-  // Tell the worker to create the PTY
-  sendMsg({ type: "create", cwd: cwd, cols: 80, rows: 24 });
-
-  return termId;
-}
-
-export function writeToTerminal(termId: string, data: string): void {
-  var worker = terminals.get(termId);
-  if (worker) {
-    worker.send({ type: "input", data: data });
-  }
-}
-
-export function resizeTerminal(termId: string, cols: number, rows: number): void {
-  var worker = terminals.get(termId);
-  if (worker) {
-    worker.send({ type: "resize", cols: cols, rows: rows });
-  }
-}
-
-export function destroyTerminal(termId: string): void {
-  var worker = terminals.get(termId);
-  if (worker) {
-    worker.send({ type: "kill" });
-    terminals.delete(termId);
-  }
-}
-
-export function getTerminal(termId: string): TerminalWorker | undefined {
-  return terminals.get(termId);
-}

package/src/server/project/warmup.ts

@@ -1,285 +0,0 @@
-import type { AccountInfo } from "@anthropic-ai/claude-agent-sdk";
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { broadcast } from "../ws/broadcast";
-import { log } from "../logger";
-import { loadConfig } from "../config";
-import { listSessions, loadSessionHistory } from "./session";
-import { execSync } from "node:child_process";
-import { existsSync, unlinkSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-
-var claudeExePath: string | null = null;
-
-function getClaudeExecutablePath(): string {
-  if (claudeExePath) return claudeExePath;
-  try {
-    claudeExePath = execSync("which claude", { encoding: "utf-8" }).trim();
-  } catch {
-    claudeExePath = "claude";
-  }
-  return claudeExePath;
-}
-
-export interface ModelEntry {
-  value: string;
-  displayName: string;
-}
-
-var KNOWN_MODELS: ModelEntry[] = [
-  { value: "default", displayName: "Default" },
-  { value: "opus", displayName: "Opus" },
-  { value: "sonnet", displayName: "Sonnet" },
-  { value: "haiku", displayName: "Haiku" },
-];
-
-var warmupModels: ModelEntry[] = [];
-var warmupSlashCommands: string[] = [];
-var warmupAccountInfo: AccountInfo | null = null;
-var warmupComplete = false;
-
-interface WarmupRateLimitEntry {
-  status: string;
-  utilization?: number;
-  resetsAt?: number;
-  rateLimitType?: string;
-  overageStatus?: string;
-  overageResetsAt?: number;
-  isUsingOverage?: boolean;
-}
-
-var warmupRateLimits: Map<string, WarmupRateLimitEntry> = new Map();
-
-function ensureKnownModels(sdkModels: ModelEntry[]): ModelEntry[] {
-  var seen = new Set<string>();
-  for (var i = 0; i < sdkModels.length; i++) {
-    seen.add(sdkModels[i].value);
-  }
-  var result = sdkModels.slice();
-  for (var j = 0; j < KNOWN_MODELS.length; j++) {
-    if (!seen.has(KNOWN_MODELS[j].value)) {
-      result.push(KNOWN_MODELS[j]);
-    }
-  }
-  return result;
-}
-
-function deleteWarmupSession(cwd: string, sessionId: string | null): void {
-  if (!sessionId) return;
-  try {
-    var hash = cwd.replace(/\//g, "-");
-    var projectDir = join(homedir(), ".claude", "projects", hash);
-    var jsonlPath = join(projectDir, sessionId + ".jsonl");
-    var dirPath = join(projectDir, sessionId);
-    if (existsSync(jsonlPath)) {
-      unlinkSync(jsonlPath);
-      log.server("Deleted warmup session file: %s", sessionId);
-    }
-    if (existsSync(dirPath)) {
-      rmSync(dirPath, { recursive: true, force: true });
-    }
-  } catch (err) {
-    log.server("Failed to delete warmup session: %O", err);
-  }
-}
-
-export async function runWarmup(cwd: string): Promise<void> {
-  log.server("SDK warmup starting (cwd: %s)...", cwd);
-  try {
-    var ac = new AbortController();
-    var ended = false;
-    var WARMUP_SESSION_ID = "lattice-warmup";
-
-    var mq = {
-      [Symbol.asyncIterator]: function () {
-        return {
-          next: function () {
-            if (ended) return Promise.resolve({ value: undefined as any, done: true });
-            ended = true;
-            return Promise.resolve({
-              value: {
-                type: "user" as const,
-                message: { role: "user" as const, content: [{ type: "text" as const, text: "hi" }] },
-                parent_tool_use_id: null,
-                session_id: WARMUP_SESSION_ID,
-              },
-              done: false,
-            });
-          },
-        };
-      },
-    };
-
-    var stream = query({
-      prompt: mq as any,
-      options: {
-        cwd,
-        sessionId: WARMUP_SESSION_ID,
-        settingSources: ["user", "project", "local"],
-        abortController: ac,
-        permissionMode: "plan",
-        pathToClaudeCodeExecutable: getClaudeExecutablePath(),
-        stderr: function (data: string) {
-          log.server("Warmup stderr: %s", data.trim());
-        },
-      },
-    });
-
-    for await (var msg of stream) {
-      if (msg.type === "system") {
-        var sysMsg = msg as any;
-        if (sysMsg.subtype === "init") {
-          if (sysMsg.slash_commands) {
-            warmupSlashCommands = sysMsg.slash_commands;
-          }
-
-          try {
-            var models = await stream.supportedModels();
-            warmupModels = ensureKnownModels((models || []) as ModelEntry[]);
-          } catch {
-            warmupModels = KNOWN_MODELS.slice();
-          }
-
-          try {
-            warmupAccountInfo = await stream.accountInfo();
-          } catch {}
-
-          ac.abort();
-          break;
-        }
-      }
-
-      if (msg.type === "rate_limit_event") {
-        var rlMsg = msg as { type: string; rate_limit_info: { status: string; utilization?: number; resetsAt?: number; rateLimitType?: string; overageStatus?: string; overageResetsAt?: number; isUsingOverage?: boolean } };
-        var rli = rlMsg.rate_limit_info;
-        var cacheKey = rli.rateLimitType || "default";
-        warmupRateLimits.set(cacheKey, {
-          status: rli.status,
-          utilization: rli.utilization,
-          resetsAt: rli.resetsAt,
-          rateLimitType: rli.rateLimitType,
-          overageStatus: rli.overageStatus,
-          overageResetsAt: rli.overageResetsAt,
-          isUsingOverage: rli.isUsingOverage,
-        });
-        broadcast({
-          type: "chat:rate_limit",
-          status: rli.status,
-          utilization: rli.utilization,
-          resetsAt: rli.resetsAt,
-          rateLimitType: rli.rateLimitType,
-          overageStatus: rli.overageStatus,
-          overageResetsAt: rli.overageResetsAt,
-          isUsingOverage: rli.isUsingOverage,
-        } as any);
-      }
-    }
-
-    warmupComplete = true;
-    deleteWarmupSession(cwd, WARMUP_SESSION_ID);
-    log.server("SDK warmup complete: %d models, %d commands, auth=%s",
-      warmupModels.length, warmupSlashCommands.length,
-      warmupAccountInfo?.apiKeySource || "unknown");
-    if (warmupAccountInfo) {
-      log.server("Account: email=%s org=%s subscription=%s provider=%s source=%s",
-        warmupAccountInfo.email || "none",
-        warmupAccountInfo.organization || "none",
-        warmupAccountInfo.subscriptionType || "none",
-        warmupAccountInfo.apiProvider || "none",
-        warmupAccountInfo.apiKeySource || "none");
-    }
-
-    broadcast({
-      type: "warmup:models",
-      models: warmupModels,
-    } as any);
-
-    if (warmupAccountInfo) {
-      broadcast({
-        type: "warmup:account",
-        email: warmupAccountInfo.email,
-        organization: warmupAccountInfo.organization,
-        subscriptionType: warmupAccountInfo.subscriptionType,
-        apiKeySource: warmupAccountInfo.apiKeySource,
-        apiProvider: warmupAccountInfo.apiProvider,
-      } as any);
-    }
-
-    void warmupProjectData();
-  } catch (err) {
-    if (err && (err as any).name !== "AbortError" && !(err instanceof Error && err.message.includes("aborted"))) {
-      log.server("SDK warmup failed: %O", err);
-    }
-    warmupModels = KNOWN_MODELS.slice();
-    warmupComplete = true;
-    void warmupProjectData();
-  }
-}
-
-async function warmupProjectData(): Promise<void> {
-  var t0 = Date.now();
-  var config = loadConfig();
-  var projects = config.projects;
-  if (projects.length === 0) return;
-
-  log.server("Data warmup: pre-caching %d project(s)...", projects.length);
-
-  var totalSessions = 0;
-  var recentSessionIds: Array<{ projectSlug: string; sessionId: string }> = [];
-
-  for (var i = 0; i < projects.length; i++) {
-    try {
-      var result = await listSessions(projects[i].slug, { limit: 40 });
-      totalSessions += result.sessions.length;
-      broadcast({
-        type: "session:list",
-        projectSlug: projects[i].slug,
-        sessions: result.sessions,
-        totalCount: result.totalCount,
-      } as any);
-      var preWarmCount = Math.min(5, result.sessions.length);
-      for (var k = 0; k < preWarmCount; k++) {
-        recentSessionIds.push({
-          projectSlug: projects[i].slug,
-          sessionId: result.sessions[k].id,
-        });
-      }
-    } catch {}
-  }
-
-  log.server("Data warmup: cached %d sessions across %d projects (%dms)", totalSessions, projects.length, Date.now() - t0);
-
-  for (var j = 0; j < recentSessionIds.length; j++) {
-    try {
-      await loadSessionHistory(recentSessionIds[j].projectSlug, recentSessionIds[j].sessionId);
-    } catch {}
-  }
-  if (recentSessionIds.length > 0) {
-    log.server("Data warmup: pre-cached history for %d recent sessions (%dms)", recentSessionIds.length, Date.now() - t0);
-  }
-}
-
-export function getWarmupModels(): ModelEntry[] {
-  return warmupModels.length > 0 ? warmupModels : KNOWN_MODELS.slice();
-}
-
-export function getWarmupSlashCommands(): string[] {
-  return warmupSlashCommands;
-}
-
-export function getWarmupAccountInfo(): AccountInfo | null {
-  return warmupAccountInfo;
-}
-
-export function getWarmupRateLimits(): WarmupRateLimitEntry[] {
-  return Array.from(warmupRateLimits.values());
-}
-
-export function cacheRateLimitEntry(entry: WarmupRateLimitEntry): void {
-  var key = entry.rateLimitType || "default";
-  warmupRateLimits.set(key, entry);
-}
-
-export function isWarmupComplete(): boolean {
-  return warmupComplete;
-}

package/src/server/push.ts

@@ -1,121 +0,0 @@
-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/tls.ts

@@ -1,65 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import { getLatticeHome } from "./config";
-
-export interface CertPaths {
-  cert: string;
-  key: string;
-}
-
-export function getCertsDir(): string {
-  var certsDir = join(getLatticeHome(), "certs");
-  if (!existsSync(certsDir)) {
-    mkdirSync(certsDir, { recursive: true });
-  }
-  return certsDir;
-}
-
-function isCertExpiringSoon(certPath: string): boolean {
-  try {
-    var result = spawnSync("openssl", ["x509", "-enddate", "-noout", "-in", certPath], { encoding: "utf-8" });
-    if (result.status !== 0) return true;
-    var match = result.stdout.match(/notAfter=(.+)/);
-    if (!match) return true;
-    var expiryDate = new Date(match[1]);
-    var daysLeft = (expiryDate.getTime() - Date.now()) / (1000 * 60 * 60 * 24);
-    return daysLeft < 30;
-  } catch {
-    return true;
-  }
-}
-
-export function ensureCerts(): CertPaths {
-  var certsDir = getCertsDir();
-  var certPath = join(certsDir, "cert.pem");
-  var keyPath = join(certsDir, "key.pem");
-
-  if (existsSync(certPath) && existsSync(keyPath) && !isCertExpiringSoon(certPath)) {
-    return { cert: certPath, key: keyPath };
-  }
-
-  console.log("[lattice] Generating self-signed TLS certificate...");
-
-  var result = spawnSync(
-    "openssl",
-    [
-      "req", "-x509",
-      "-newkey", "rsa:2048",
-      "-keyout", keyPath,
-      "-out", certPath,
-      "-days", "365",
-      "-nodes",
-      "-subj", "/CN=lattice",
-    ],
-    { encoding: "utf-8" }
-  );
-
-  if (result.status !== 0) {
-    throw new Error("[lattice] Failed to generate TLS certificates: " + (result.stderr || result.error?.message || "unknown error"));
-  }
-
-  console.log("[lattice] TLS certificates generated at " + certsDir);
-
-  return { cert: certPath, key: keyPath };
-}

package/src/server/tui.ts

@@ -1,103 +0,0 @@
-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 "#shared";
-import { DEFAULT_PORT } from "#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 };
-}