@cryptiklemur/lattice 4.0.1 → 5.0.0

package/dist/server/mesh/proxy.js

@@ -0,0 +1,86 @@
+import { randomUUID } from "node:crypto";
+import { getPeerConnection } from "./connector.js";
+import { sendTo, registerVirtualClient, removeVirtualClient } from "../ws/broadcast.js";
+import { routeMessage } from "../ws/router.js";
+import { log } from "../logger.js";
+var pendingRequests = new Map();
+export function proxyToRemoteNode(nodeId, projectSlug, clientId, message) {
+    log.meshProxy("→ proxy %s to node %s for project %s", message.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 = {
+        type: "mesh:proxy_request",
+        projectSlug: projectSlug,
+        requestId: requestId,
+        payload: message,
+    };
+    ws.send(JSON.stringify(envelope));
+}
+export function handleProxyRequest(sourceNodeId, msg) {
+    var proxyClientId = "mesh-proxy:" + sourceNodeId + ":" + msg.requestId;
+    log.meshProxy("← proxy_request from %s: %s for %s (reqId=%s)", sourceNodeId.slice(0, 8), msg.payload.type, msg.projectSlug, msg.requestId.slice(0, 8));
+    registerVirtualClient(proxyClientId, function (response) {
+        log.meshProxy("  → proxy_response %s back to %s", response.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 = {
+            type: "mesh:proxy_response",
+            projectSlug: msg.projectSlug,
+            requestId: msg.requestId,
+            payload: response,
+        };
+        ws.send(JSON.stringify(envelope));
+        removeVirtualClient(proxyClientId);
+    });
+    routeMessage(proxyClientId, msg.payload);
+}
+export function handleProxyResponse(msg) {
+    log.meshProxy("← proxy_response %s (reqId=%s)", msg.payload.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);
+}
+var proxyHandlers = new Map();
+export function registerProxyAwareHandler(prefix, handler) {
+    proxyHandlers.set(prefix, handler);
+}
+function proxyRouteMessage(clientId, message, sendToFn) {
+    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, sourceNodeId) {
+    var clientId = pendingRequests.get(requestId);
+    if (clientId !== undefined) {
+        var resolvedClientId = clientId;
+        return function (msg) {
+            sendTo(resolvedClientId, msg);
+        };
+    }
+    return function (msg) {
+        var ws = getPeerConnection(sourceNodeId);
+        if (!ws) {
+            return;
+        }
+        ws.send(JSON.stringify(msg));
+    };
+}

package/dist/server/mesh/session-sync.js

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getConnectedPeerIds, getPeerConnection } from "./connector.js";
+import { getLatticeHome } from "../config.js";
+var syncOffsets = new Map();
+function getSyncKey(nodeId, sessionId) {
+    return nodeId + ":" + sessionId;
+}
+function getRemoteSessionsDir(nodeId, projectSlug) {
+    var dir = join(getLatticeHome(), "remote-sessions", nodeId, projectSlug);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function getSessionFilePath(projectPath, sessionId) {
+    var hash = projectPath.replace(/\//g, "-");
+    return join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+}
+export function syncSessionToPeers(projectPath, projectSlug, sessionId) {
+    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 = {
+            type: "mesh:session_sync",
+            projectSlug,
+            sessionId,
+            lines: newLines,
+            offset: lastOffset,
+        };
+        ws.send(JSON.stringify(msg));
+        syncOffsets.set(key, content.length);
+    }
+}
+export function handleSessionSync(nodeId, msg) {
+    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, msg, projectPath) {
+    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 = {
+        type: "mesh:session_sync",
+        projectSlug: msg.projectSlug,
+        sessionId: msg.sessionId,
+        lines,
+        offset: msg.fromOffset,
+    };
+    ws.send(JSON.stringify(syncMsg));
+}

package/dist/server/project/bookmarks.js

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getLatticeHome } from "../config.js";
+var bookmarksFile = "";
+var bookmarks = [];
+function getBookmarksPath() {
+    if (!bookmarksFile) {
+        bookmarksFile = join(getLatticeHome(), "bookmarks.json");
+    }
+    return bookmarksFile;
+}
+export function loadBookmarks() {
+    var path = getBookmarksPath();
+    if (!existsSync(path)) {
+        bookmarks = [];
+        return;
+    }
+    try {
+        var raw = readFileSync(path, "utf-8");
+        bookmarks = JSON.parse(raw);
+    }
+    catch (err) {
+        console.error("[bookmarks] Failed to load bookmarks:", err);
+        bookmarks = [];
+    }
+}
+function saveBookmarks() {
+    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, sessionId) {
+    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) {
+    var now = Date.now();
+    var entry = {
+        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) {
+    for (var i = 0; i < bookmarks.length; i++) {
+        if (bookmarks[i].id === id) {
+            bookmarks.splice(i, 1);
+            saveBookmarks();
+            return true;
+        }
+    }
+    return false;
+}

package/dist/server/project/context-breakdown.js

@@ -0,0 +1,279 @@
+import { encodingForModel } from "js-tiktoken";
+import { existsSync, readFileSync, readdirSync, openSync, readSync, fstatSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { guessContextWindow } from "./session.js";
+import { loadConfig } from "../config.js";
+import { getInstalledPluginCount, getPluginSkillRuleTokenEstimate } from "../handlers/plugins.js";
+var encoder = encodingForModel("gpt-4o");
+function countTokens(text) {
+    if (!text)
+        return 0;
+    return encoder.encode(text).length;
+}
+function readFileSafe(path) {
+    try {
+        if (existsSync(path))
+            return readFileSync(path, "utf-8");
+    }
+    catch { }
+    return "";
+}
+function readDirFiles(dirPath) {
+    try {
+        if (!existsSync(dirPath))
+            return "";
+        var files = readdirSync(dirPath, { withFileTypes: true });
+        var content = "";
+        for (var i = 0; i < files.length; i++) {
+            if (files[i].isFile()) {
+                content += readFileSafe(join(dirPath, files[i].name)) + "\n";
+            }
+        }
+        return content;
+    }
+    catch { }
+    return "";
+}
+function projectPathToHash(projectPath) {
+    return projectPath.replace(/\//g, "-");
+}
+function getProjectPath(projectSlug) {
+    var config = loadConfig();
+    var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+    return project ? project.path : null;
+}
+// Known built-in Claude Code tools with approximate per-tool token counts
+// These are the tool definitions sent in every API request
+var BUILTIN_TOOLS = {
+    "Read": 350,
+    "Write": 300,
+    "Edit": 400,
+    "Bash": 500,
+    "Glob": 250,
+    "Grep": 450,
+    "Agent": 600,
+    "WebFetch": 400,
+    "WebSearch": 300,
+    "TodoWrite": 300,
+    "NotebookEdit": 350,
+    "AskUserQuestion": 400,
+    "Skill": 350,
+    "TaskOutput": 200,
+    "TaskStop": 150,
+    "EnterPlanMode": 200,
+    "ExitPlanMode": 150,
+    "EnterWorktree": 200,
+    "ExitWorktree": 150,
+    "CronCreate": 250,
+    "CronDelete": 200,
+    "CronList": 150,
+    "ToolSearch": 250,
+};
+// Average tokens per MCP tool definition (name + description + JSON schema)
+var MCP_TOOL_AVG_TOKENS = 250;
+function extractToolsFromSession(lines) {
+    var builtinSet = new Set();
+    var mcpMap = new Map();
+    // First: check compact boundary metadata for preCompactDiscoveredTools
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i].trim();
+        if (!line || !line.includes("compactMetadata"))
+            continue;
+        try {
+            var parsed = JSON.parse(line);
+            var tools = parsed.compactMetadata?.preCompactDiscoveredTools;
+            if (Array.isArray(tools)) {
+                for (var t = 0; t < tools.length; t++) {
+                    categorizeToolName(tools[t], builtinSet, mcpMap);
+                }
+            }
+        }
+        catch { }
+    }
+    // Second: scan tool_use blocks from assistant messages for any we missed
+    for (var j = 0; j < lines.length; j++) {
+        var aLine = lines[j].trim();
+        if (!aLine || !aLine.includes("tool_use"))
+            continue;
+        try {
+            var aParsed = JSON.parse(aLine);
+            if (aParsed.type === "assistant" && aParsed.message && Array.isArray(aParsed.message.content)) {
+                for (var k = 0; k < aParsed.message.content.length; k++) {
+                    var block = aParsed.message.content[k];
+                    if (block.type === "tool_use" && block.name) {
+                        categorizeToolName(block.name, builtinSet, mcpMap);
+                    }
+                }
+            }
+        }
+        catch { }
+    }
+    // If we found no tools at all, use the default known set
+    if (builtinSet.size === 0 && mcpMap.size === 0) {
+        return {
+            builtinTools: Object.keys(BUILTIN_TOOLS),
+            mcpTools: new Map(),
+        };
+    }
+    return {
+        builtinTools: Array.from(builtinSet),
+        mcpTools: new Map(Array.from(mcpMap.entries()).map(function (entry) {
+            return [entry[0], Array.from(entry[1])];
+        })),
+    };
+}
+function categorizeToolName(name, builtinSet, mcpMap) {
+    if (name.startsWith("mcp__")) {
+        var parts = name.split("__");
+        var serverName = parts[1] || "unknown";
+        if (!mcpMap.has(serverName)) {
+            mcpMap.set(serverName, new Set());
+        }
+        mcpMap.get(serverName).add(name);
+    }
+    else {
+        builtinSet.add(name);
+    }
+}
+function estimateBuiltinToolTokens(toolNames) {
+    var total = 0;
+    for (var i = 0; i < toolNames.length; i++) {
+        total += BUILTIN_TOOLS[toolNames[i]] || 300;
+    }
+    // Also include tools that are always sent but might not appear in usage
+    var knownKeys = Object.keys(BUILTIN_TOOLS);
+    for (var j = 0; j < knownKeys.length; j++) {
+        if (toolNames.indexOf(knownKeys[j]) === -1) {
+            total += BUILTIN_TOOLS[knownKeys[j]];
+        }
+    }
+    return total;
+}
+export async function getContextBreakdown(projectSlug, sessionId) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath)
+        return null;
+    var home = homedir();
+    var hash = projectPathToHash(projectPath);
+    var sessionFile = join(home, ".claude", "projects", hash, sessionId + ".jsonl");
+    if (!existsSync(sessionFile))
+        return null;
+    // Read instruction files
+    var globalClaudeMd = readFileSafe(join(home, ".claude", "CLAUDE.md"));
+    var globalRulesContent = readDirFiles(join(home, ".claude", "rules"));
+    var projectClaudeMd = readFileSafe(join(projectPath, "CLAUDE.md"));
+    var projectLocalClaudeMd = readFileSafe(join(home, ".claude", "projects", hash, "CLAUDE.md"));
+    var memoryContent = readDirFiles(join(home, ".claude", "projects", hash, "memory"));
+    var memoryIndex = readFileSafe(join(home, ".claude", "projects", hash, "MEMORY.md"));
+    var instructionsTokens = countTokens(globalClaudeMd + globalRulesContent + projectClaudeMd + projectLocalClaudeMd);
+    var memoryTokens = countTokens(memoryContent + memoryIndex);
+    // Parse session — read last 2MB for recent context (avoids reading 35MB+ files)
+    var fd = openSync(sessionFile, "r");
+    var fileStat = fstatSync(fd);
+    var readSize = Math.min(fileStat.size, 2 * 1024 * 1024);
+    var readBuf = Buffer.alloc(readSize);
+    readSync(fd, readBuf, 0, readSize, fileStat.size - readSize);
+    closeSync(fd);
+    var content = readBuf.toString("utf-8");
+    var lines = content.split("\n").filter(function (l) { return l.length > 0; });
+    // Extract tool info
+    var toolCounts = extractToolsFromSession(lines);
+    var builtinToolTokens = estimateBuiltinToolTokens(toolCounts.builtinTools);
+    // Parse conversation messages
+    var userText = "";
+    var assistantText = "";
+    var toolResultText = "";
+    var contextWindow = 0;
+    var lastModel = "";
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i].trim();
+        if (!line)
+            continue;
+        try {
+            var parsed = JSON.parse(line);
+            if (parsed.type === "user" && parsed.message) {
+                var userContent = parsed.message.content;
+                if (typeof userContent === "string") {
+                    userText += userContent + "\n";
+                }
+                else if (Array.isArray(userContent)) {
+                    for (var j = 0; j < userContent.length; j++) {
+                        var block = userContent[j];
+                        if (block.type === "text" && block.text) {
+                            userText += block.text + "\n";
+                        }
+                        else if (block.type === "tool_result") {
+                            if (typeof block.content === "string") {
+                                toolResultText += block.content + "\n";
+                            }
+                            else if (Array.isArray(block.content)) {
+                                for (var ri = 0; ri < block.content.length; ri++) {
+                                    if (block.content[ri].type === "text" && block.content[ri].text) {
+                                        toolResultText += block.content[ri].text + "\n";
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else if (parsed.type === "assistant" && parsed.message) {
+                var aContent = parsed.message.content;
+                if (typeof aContent === "string") {
+                    assistantText += aContent + "\n";
+                }
+                else if (Array.isArray(aContent)) {
+                    for (var k = 0; k < aContent.length; k++) {
+                        var ab = aContent[k];
+                        if (ab.type === "text" && ab.text) {
+                            assistantText += ab.text + "\n";
+                        }
+                        else if (ab.type === "tool_use" && ab.input) {
+                            assistantText += JSON.stringify(ab.input) + "\n";
+                        }
+                        else if (ab.type === "thinking" && ab.thinking) {
+                            assistantText += ab.thinking + "\n";
+                        }
+                    }
+                }
+                if (parsed.message.model) {
+                    lastModel = parsed.message.model;
+                }
+            }
+        }
+        catch { }
+    }
+    var userTokens = countTokens(userText);
+    var assistantTokens = countTokens(assistantText);
+    var toolResultTokens = countTokens(toolResultText);
+    contextWindow = guessContextWindow(lastModel);
+    var autocompactAt = Math.round(contextWindow * 0.9);
+    var systemPromptEstimate = 4500;
+    var segments = [
+        { label: "System prompt", tokens: systemPromptEstimate, id: "system", estimated: true },
+        { label: "Built-in tools (" + Object.keys(BUILTIN_TOOLS).length + ")", tokens: builtinToolTokens, id: "builtin_tools", estimated: true },
+    ];
+    // Add per-MCP-server segments
+    toolCounts.mcpTools.forEach(function (tools, serverName) {
+        var mcpTokens = tools.length * MCP_TOOL_AVG_TOKENS;
+        segments.push({
+            label: serverName + " (" + tools.length + " tools)",
+            tokens: mcpTokens,
+            id: "mcp_" + serverName,
+            estimated: true,
+        });
+    });
+    var pluginCount = getInstalledPluginCount();
+    if (pluginCount > 0) {
+        var pluginTokens = getPluginSkillRuleTokenEstimate();
+        segments.push({
+            label: "Plugins (" + pluginCount + ")",
+            tokens: pluginTokens,
+            id: "plugins",
+            estimated: true,
+        });
+    }
+    segments.push({ label: "Instructions", tokens: instructionsTokens, id: "instructions", estimated: false }, { label: "Memory", tokens: memoryTokens, id: "memory", estimated: false }, { label: "Your messages", tokens: userTokens, id: "user", estimated: false }, { label: "Claude responses", tokens: assistantTokens, id: "assistant", estimated: false }, { label: "Tool results", tokens: toolResultTokens, id: "tool_results", estimated: false });
+    return { segments, contextWindow, autocompactAt };
+}

package/dist/server/project/file-browser.js

@@ -0,0 +1,97 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve, relative } from "node:path";
+var MAX_FILE_SIZE = 512 * 1024;
+export function validatePath(projectPath, relativePath) {
+    var resolved = resolve(projectPath, relativePath);
+    var normalizedRoot = resolve(projectPath);
+    if (!resolved.startsWith(normalizedRoot + "/") && resolved !== normalizedRoot) {
+        return null;
+    }
+    return resolved;
+}
+export function listDirectory(projectPath, relativePath) {
+    var fullPath = validatePath(projectPath, relativePath);
+    if (!fullPath) {
+        return [];
+    }
+    var entries = [];
+    var names;
+    try {
+        names = readdirSync(fullPath);
+    }
+    catch {
+        return [];
+    }
+    for (var i = 0; i < names.length; i++) {
+        var name = names[i];
+        if (name.startsWith(".")) {
+            continue;
+        }
+        var entryFull = join(fullPath, name);
+        try {
+            var stat = statSync(entryFull);
+            var entryRelative = relative(projectPath, entryFull);
+            entries.push({
+                name: name,
+                path: entryRelative,
+                isDirectory: stat.isDirectory(),
+                size: stat.isDirectory() ? 0 : stat.size,
+                modifiedAt: stat.mtimeMs,
+            });
+        }
+        catch {
+            // skip entries we can't stat
+        }
+    }
+    entries.sort(function (a, b) {
+        if (a.isDirectory && !b.isDirectory)
+            return -1;
+        if (!a.isDirectory && b.isDirectory)
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    return entries;
+}
+export function readFile(projectPath, relativePath) {
+    var fullPath = validatePath(projectPath, relativePath);
+    if (!fullPath) {
+        return null;
+    }
+    var stat;
+    try {
+        stat = statSync(fullPath);
+    }
+    catch {
+        return null;
+    }
+    if (stat.size > MAX_FILE_SIZE) {
+        return null;
+    }
+    var buf;
+    try {
+        buf = readFileSync(fullPath);
+    }
+    catch {
+        return null;
+    }
+    for (var i = 0; i < Math.min(buf.length, 8192); i++) {
+        var byte = buf[i];
+        if (byte === 0) {
+            return null;
+        }
+    }
+    return buf.toString("utf-8");
+}
+export function writeFile(projectPath, relativePath, content) {
+    var fullPath = validatePath(projectPath, relativePath);
+    if (!fullPath) {
+        return false;
+    }
+    try {
+        writeFileSync(fullPath, content, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}