@cryptiklemur/lattice 1.46.7 → 2.0.0

package/{server/src → src/server}/project/session.ts

@@ -5,7 +5,8 @@ import {
   renameSession as sdkRenameSession,
 } from "@anthropic-ai/claude-agent-sdk";
 import type { SDKSessionInfo, SessionMessage } from "@anthropic-ai/claude-agent-sdk";
-import { existsSync, unlinkSync, readFileSync } from "node:fs";
+import { existsSync, unlinkSync, readFileSync, statSync } from "node:fs";
+import * as fsPromises from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
@@ -138,8 +139,16 @@ function extractUserText(content: unknown): string {
   return "";
 }
 
+var HIDDEN_TOOLS = new Set([
+  "TaskUpdate", "TaskCreate", "TaskGet", "TaskList", "TaskOutput", "TaskStop",
+  "TodoWrite", "TodoRead",
+  "EnterPlanMode", "ExitPlanMode",
+  "ToolSearch",
+]);
+
 function convertSessionMessages(messages: SessionMessage[]): HistoryMessage[] {
   var result: HistoryMessage[] = [];
+  var hiddenToolIds = new Set<string>();
 
   for (var i = 0; i < messages.length; i++) {
     var msg = messages[i];
@@ -147,11 +156,24 @@ function convertSessionMessages(messages: SessionMessage[]): HistoryMessage[] {
     var apiMsg = msg.message as { role?: string; content?: unknown };
 
     if (msg.type === "user") {
+      if ((msg as Record<string, unknown>).isCompactSummary === true) {
+        var summaryText = typeof apiMsg.content === "string" ? apiMsg.content : "";
+        if (summaryText) {
+          result.push({
+            type: "compact_summary",
+            uuid: msg.uuid,
+            text: summaryText,
+            timestamp: ts,
+          });
+        }
+        continue;
+      }
       if (Array.isArray(apiMsg.content)) {
         var hadToolResult = false;
         for (var j = 0; j < apiMsg.content.length; j++) {
           var block = apiMsg.content[j] as { type?: string; text?: string; tool_use_id?: string; content?: unknown };
           if (block.type === "tool_result" && block.tool_use_id) {
+            if (hiddenToolIds.has(block.tool_use_id)) continue;
             hadToolResult = true;
             var resultContent = "";
             if (typeof block.content === "string") {
@@ -212,13 +234,17 @@ function convertSessionMessages(messages: SessionMessage[]): HistoryMessage[] {
               timestamp: ts,
             });
           } else if (aBlock.type === "tool_use" && aBlock.id && aBlock.name) {
-            result.push({
-              type: "tool_start",
-              toolId: aBlock.id,
-              name: aBlock.name,
-              args: JSON.stringify(aBlock.input ?? {}),
-              timestamp: ts,
-            });
+            if (HIDDEN_TOOLS.has(aBlock.name)) {
+              hiddenToolIds.add(aBlock.id);
+            } else {
+              result.push({
+                type: "tool_start",
+                toolId: aBlock.id,
+                name: aBlock.name,
+                args: JSON.stringify(aBlock.input ?? {}),
+                timestamp: ts,
+              });
+            }
           }
         }
         if (msgUsage && lastAssistantIdx >= 0) {
@@ -294,15 +320,14 @@ export async function getSessionUsage(projectSlug: string, sessionId: string): P
   if (!existsSync(sessionFile)) return null;
 
   try {
-    var { openSync, readSync, fstatSync, closeSync } = require("node:fs") as typeof import("node:fs");
-    var fd = openSync(sessionFile, "r");
-    var stat = fstatSync(fd);
-    var tailSize = Math.min(stat.size, 512 * 1024);
-    var buf = Buffer.alloc(tailSize);
-    readSync(fd, buf, 0, tailSize, stat.size - tailSize);
-    closeSync(fd);
-
-    var text = buf.toString("utf-8");
+    var fhUsage = await fsPromises.open(sessionFile, "r");
+    var statUsage = await fhUsage.stat();
+    var tailSize = Math.min(statUsage.size, 512 * 1024);
+    var bufUsage = Buffer.alloc(tailSize);
+    await fhUsage.read(bufUsage, 0, tailSize, statUsage.size - tailSize);
+    await fhUsage.close();
+
+    var text = bufUsage.toString("utf-8");
     var lines = text.split("\n");
 
     for (var i = lines.length - 1; i >= 0; i--) {
@@ -453,6 +478,12 @@ export function invalidateSessionCache(projectSlug: string): void {
   sessionListCache.delete(projectSlug);
 }
 
+export function invalidateHistoryCache(sessionId: string): void {
+  historyCache.delete(sessionId);
+  var idx = historyCacheOrder.indexOf(sessionId);
+  if (idx >= 0) historyCacheOrder.splice(idx, 1);
+}
+
 export async function getSessionTitle(projectSlug: string, sessionId: string): Promise<string> {
   var projectPath = getProjectPath(projectSlug);
   var options = projectPath ? { dir: projectPath } : undefined;
@@ -465,10 +496,32 @@ export async function getSessionTitle(projectSlug: string, sessionId: string): P
   return "Untitled";
 }
 
-var historyCache = new Map<string, { messages: HistoryMessage[]; time: number }>();
-var HISTORY_CACHE_TTL = 60000;
-var INITIAL_MESSAGE_COUNT = 100;
-var TAIL_READ_BYTES = 2 * 1024 * 1024;
+var historyCache = new Map<string, { messages: HistoryMessage[]; title: string | null }>();
+var historyCacheOrder: string[] = [];
+var MAX_HISTORY_CACHE = 50;
+
+function touchCache(sessionId: string): void {
+  var idx = historyCacheOrder.indexOf(sessionId);
+  if (idx >= 0) historyCacheOrder.splice(idx, 1);
+  historyCacheOrder.push(sessionId);
+}
+
+function evictOldest(): void {
+  while (historyCacheOrder.length > MAX_HISTORY_CACHE) {
+    var oldest = historyCacheOrder.shift();
+    if (oldest) historyCache.delete(oldest);
+  }
+}
+
+export function appendToHistoryCache(sessionId: string, message: HistoryMessage): void {
+  var cached = historyCache.get(sessionId);
+  if (!cached) return;
+  cached.messages.push(message);
+  touchCache(sessionId);
+}
+
+var INITIAL_MESSAGE_COUNT = 300;
+var TAIL_READ_BYTES = 512 * 1024;
 
 function getSessionFilePath(projectSlug: string, sessionId: string): string | null {
   var projectPath = getProjectPath(projectSlug);
@@ -478,21 +531,34 @@ function getSessionFilePath(projectSlug: string, sessionId: string): string | nu
   return existsSync(filePath) ? filePath : null;
 }
 
-function readTailLines(filePath: string, maxBytes: number): { lines: string[]; isPartial: boolean; fileSize: number } {
-  var { openSync, readSync, fstatSync, closeSync } = require("node:fs") as typeof import("node:fs");
-  var fd = openSync(filePath, "r");
-  var stat = fstatSync(fd);
-  var readStart = Math.max(0, stat.size - maxBytes);
-  var buf = Buffer.alloc(stat.size - readStart);
-  readSync(fd, buf, 0, buf.length, readStart);
-  closeSync(fd);
-  var text = buf.toString("utf-8");
-  if (readStart > 0) {
-    var firstNewline = text.indexOf("\n");
-    if (firstNewline >= 0) text = text.slice(firstNewline + 1);
+export function getSessionFileSizeBytes(projectSlug: string, sessionId: string): number | null {
+  var filePath = getSessionFilePath(projectSlug, sessionId);
+  if (!filePath) return null;
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return null;
+  }
+}
+
+async function readTailLines(filePath: string, maxBytes: number): Promise<{ lines: string[]; isPartial: boolean; fileSize: number }> {
+  var fh = await fsPromises.open(filePath, "r");
+  try {
+    var stat = await fh.stat();
+    var readStart = Math.max(0, stat.size - maxBytes);
+    var length = stat.size - readStart;
+    var buf = Buffer.alloc(length);
+    await fh.read(buf, 0, length, readStart);
+    var text = buf.toString("utf-8");
+    if (readStart > 0) {
+      var firstNewline = text.indexOf("\n");
+      if (firstNewline >= 0) text = text.slice(firstNewline + 1);
+    }
+    var lines = text.split("\n").filter(function (l) { return l.length > 0; });
+    return { lines, isPartial: readStart > 0, fileSize: stat.size };
+  } finally {
+    await fh.close();
   }
-  var lines = text.split("\n").filter(function (l) { return l.length > 0; });
-  return { lines, isPartial: readStart > 0, fileSize: stat.size };
 }
 
 function parseJsonlLines(lines: string[]): SessionMessage[] {
@@ -512,7 +578,8 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
   try {
     var t0 = Date.now();
     var cached = historyCache.get(sessionId);
-    if (cached && Date.now() - cached.time < HISTORY_CACHE_TTL) {
+    if (cached) {
+      touchCache(sessionId);
       var tail = cached.messages.length > INITIAL_MESSAGE_COUNT
         ? cached.messages.slice(cached.messages.length - INITIAL_MESSAGE_COUNT)
         : cached.messages;
@@ -522,15 +589,17 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
 
     var filePath = getSessionFilePath(projectSlug, sessionId);
     if (filePath) {
-      var tailData = readTailLines(filePath, TAIL_READ_BYTES);
+      var tailData = await readTailLines(filePath, TAIL_READ_BYTES);
       var tailRaw = parseJsonlLines(tailData.lines);
       var tailMessages = convertSessionMessages(tailRaw);
       var hasMore = tailData.isPartial;
 
       log.session("loadSessionHistory %s: %dms (tail read, %d msgs, partial=%s)", sessionId.slice(0, 8), Date.now() - t0, tailMessages.length, hasMore);
 
-      if (!hasMore) {
-        historyCache.set(sessionId, { messages: tailMessages, time: Date.now() });
+      if (!hasMore && tailMessages.length > 0) {
+        historyCache.set(sessionId, { messages: tailMessages, title: null });
+        touchCache(sessionId);
+        evictOldest();
       }
 
       var initialSlice = tailMessages.length > INITIAL_MESSAGE_COUNT
@@ -544,7 +613,11 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
     var options = projectPath ? { dir: projectPath } : undefined;
     var rawMessages = await getSessionMessages(sessionId, options);
     var allMessages = convertSessionMessages(rawMessages);
-    historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+    if (allMessages.length > 0) {
+      historyCache.set(sessionId, { messages: allMessages, title: null });
+      touchCache(sessionId);
+      evictOldest();
+    }
     log.session("loadSessionHistory %s: %dms (full SDK, %d msgs)", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
     var tailSlice = allMessages.length > INITIAL_MESSAGE_COUNT
       ? allMessages.slice(allMessages.length - INITIAL_MESSAGE_COUNT)
@@ -564,8 +637,10 @@ export async function getSessionHistoryPage(sessionId: string, beforeIndex: numb
     try {
       var rawMessages = await getSessionMessages(sessionId, options);
       var allMessages = convertSessionMessages(rawMessages);
-      historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
-      cached = { messages: allMessages, time: Date.now() };
+      historyCache.set(sessionId, { messages: allMessages, title: null });
+      touchCache(sessionId);
+      evictOldest();
+      cached = historyCache.get(sessionId)!;
       log.session("getSessionHistoryPage: full load for %s, %d messages", sessionId.slice(0, 8), allMessages.length);
     } catch {
       return { messages: [], hasMore: false };

package/{server/src → src/server}/project/terminal.ts

@@ -1,10 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import type { ChildProcess } from "node:child_process";
-import { join } from "node:path";
-import { existsSync, writeFileSync, readFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { IS_COMPILED } from "../runtime";
+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;
@@ -13,22 +14,7 @@ interface TerminalWorker {
 
 var terminals = new Map<string, TerminalWorker>();
 
-function getWorkerPath(): string {
-  if (!IS_COMPILED) {
-    return join(import.meta.dir, "pty-worker.cjs");
-  }
-  var extractedPath = join(homedir(), ".lattice", "pty-worker.cjs");
-  if (!existsSync(extractedPath)) {
-    var srcPath = join(import.meta.dir, "pty-worker.cjs");
-    if (existsSync(srcPath)) {
-      mkdirSync(join(homedir(), ".lattice"), { recursive: true });
-      writeFileSync(extractedPath, readFileSync(srcPath));
-    }
-  }
-  return extractedPath;
-}
-
-var WORKER_PATH = getWorkerPath();
+var WORKER_PATH = join(__dirname_local, "pty-worker.cjs");
 
 var NODE_MODULES_PATH = (function () {
   try {
@@ -37,10 +23,7 @@ var NODE_MODULES_PATH = (function () {
     parts.pop();
     return parts.join("/node_modules/") + "/node_modules";
   } catch {
-    if (IS_COMPILED) {
-      return "";
-    }
-    return join(import.meta.dir, "..", "..", "..", "node_modules");
+    return join(__dirname_local, "..", "..", "..", "node_modules");
   }
 })();
 

package/src/server/project/warmup.ts

@@ -0,0 +1,285 @@
+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;
+}