@cryptiklemur/lattice 4.0.2 → 5.0.1

package/dist/server/handlers/bookmarks.js

@@ -0,0 +1,41 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { listBookmarks, addBookmark, removeBookmark } from "../project/bookmarks.js";
+registerHandler("bookmark", function (clientId, message) {
+    if (message.type === "bookmark:list") {
+        var listMsg = message;
+        var isSessionScoped = Boolean(listMsg.sessionId);
+        sendTo(clientId, {
+            type: "bookmark:list_result",
+            scope: isSessionScoped ? "session" : "all",
+            bookmarks: listBookmarks(listMsg.projectSlug, listMsg.sessionId),
+        });
+        return;
+    }
+    if (message.type === "bookmark:add") {
+        var addMsg = message;
+        addBookmark({
+            sessionId: addMsg.sessionId,
+            projectSlug: addMsg.projectSlug,
+            messageUuid: addMsg.messageUuid,
+            messageText: addMsg.messageText,
+            messageType: addMsg.messageType,
+        });
+        sendTo(clientId, {
+            type: "bookmark:list_result",
+            scope: "session",
+            bookmarks: listBookmarks(addMsg.projectSlug, addMsg.sessionId),
+        });
+        return;
+    }
+    if (message.type === "bookmark:remove") {
+        var removeMsg = message;
+        removeBookmark(removeMsg.id);
+        sendTo(clientId, {
+            type: "bookmark:list_result",
+            scope: "all",
+            bookmarks: listBookmarks(),
+        });
+        return;
+    }
+});

package/dist/server/handlers/chat.js

@@ -0,0 +1,350 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { getProjectBySlug } from "../project/registry.js";
+import { loadConfig } from "../config.js";
+import { startChatStream, getPendingPermission, deletePendingPermission, addAutoApprovedTool, setSessionPermissionOverride, getActiveStream, getSessionStream, buildPermissionRule, getPendingElicitation, resolveElicitation } from "../project/sdk-bridge.js";
+import { getAttachments } from "./attachment.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getDailySpend } from "../analytics/engine.js";
+import { log } from "../logger.js";
+function formatSdkRule(rule) {
+    if (!rule.ruleContent)
+        return rule.toolName;
+    if (rule.toolName === "Bash") {
+        var firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
+        if (firstWord === "curl" || firstWord === "wget") {
+            var urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
+            if (urlMatch) {
+                try {
+                    var parsed = new URL(urlMatch[0]);
+                    return rule.toolName + "(" + firstWord + ":" + parsed.hostname + ")";
+                }
+                catch { }
+            }
+        }
+        return rule.toolName + "(" + firstWord + ":*)";
+    }
+    return rule.toolName + "(" + rule.ruleContent + ")";
+}
+function addProjectAllowRules(projectPath, suggestions, fallbackToolName, fallbackInput) {
+    var claudeDir = join(projectPath, ".claude");
+    var settingsPath = join(claudeDir, "settings.json");
+    var settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    if (!settings.permissions) {
+        settings.permissions = {};
+    }
+    var permissions = settings.permissions;
+    if (!Array.isArray(permissions.allow)) {
+        permissions.allow = [];
+    }
+    if (!Array.isArray(permissions.additionalDirectories)) {
+        permissions.additionalDirectories = [];
+    }
+    var allowList = permissions.allow;
+    var additionalDirs = permissions.additionalDirectories;
+    if (suggestions && suggestions.length > 0) {
+        for (var si = 0; si < suggestions.length; si++) {
+            var suggestion = suggestions[si];
+            if (suggestion.type === "addRules" && suggestion.behavior === "allow" && suggestion.rules) {
+                for (var ri = 0; ri < suggestion.rules.length; ri++) {
+                    var rule = formatSdkRule(suggestion.rules[ri]);
+                    if (!allowList.includes(rule)) {
+                        allowList.push(rule);
+                    }
+                    if (suggestion.rules[ri].ruleContent) {
+                        var ruleDir = suggestion.rules[ri].ruleContent.replace(/\/\*\*$/, "").replace(/^\//, "");
+                        if (ruleDir.startsWith("/") && !additionalDirs.includes(ruleDir)) {
+                            additionalDirs.push(ruleDir);
+                        }
+                    }
+                }
+            }
+            if (suggestion.type === "addDirectories" && suggestion.directories) {
+                for (var di = 0; di < suggestion.directories.length; di++) {
+                    if (!additionalDirs.includes(suggestion.directories[di])) {
+                        additionalDirs.push(suggestion.directories[di]);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        var fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
+        if (!allowList.includes(fallbackRule)) {
+            allowList.push(fallbackRule);
+        }
+    }
+    if (!existsSync(claudeDir)) {
+        mkdirSync(claudeDir, { recursive: true });
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+}
+var activeSessionByClient = new Map();
+var pendingBudgetOverride = new Map();
+export function sendBudgetStatus(clientId) {
+    var config = loadConfig();
+    if (!config.costBudget)
+        return;
+    var dailySpend = getDailySpend();
+    sendTo(clientId, {
+        type: "budget:status",
+        dailySpend: dailySpend,
+        dailyLimit: config.costBudget.dailyLimit,
+        enforcement: config.costBudget.enforcement,
+    });
+}
+export function setActiveSession(clientId, projectSlug, sessionId) {
+    activeSessionByClient.set(clientId, { projectSlug, sessionId });
+}
+export function clearActiveSession(clientId) {
+    activeSessionByClient.delete(clientId);
+}
+export function getActiveSession(clientId) {
+    return activeSessionByClient.get(clientId);
+}
+registerHandler("budget", function (clientId, message) {
+    if (message.type === "budget:override") {
+        var pending = pendingBudgetOverride.get(clientId);
+        if (!pending)
+            return;
+        pendingBudgetOverride.delete(clientId);
+        var overrideAttachments = pending.sendMsg.attachmentIds
+            ? getAttachments(clientId, pending.sendMsg.attachmentIds)
+            : [];
+        startChatStream({
+            projectSlug: pending.projectSlug,
+            sessionId: pending.sessionId,
+            text: pending.sendMsg.text,
+            attachments: overrideAttachments,
+            clientId,
+            cwd: pending.cwd,
+            env: pending.env,
+            model: pending.sendMsg.model,
+            effort: pending.sendMsg.effort,
+        });
+        return;
+    }
+});
+registerHandler("chat", function (clientId, message) {
+    if (message.type === "chat:send") {
+        var sendMsg = message;
+        var active = activeSessionByClient.get(clientId);
+        if (!active) {
+            sendTo(clientId, { type: "chat:error", message: "No active session. Activate a session first." });
+            return;
+        }
+        var project = getProjectBySlug(active.projectSlug);
+        if (!project) {
+            sendTo(clientId, { type: "chat:error", message: `Project not found: ${active.projectSlug}` });
+            return;
+        }
+        var config = loadConfig();
+        var env = Object.assign({}, config.globalEnv, project.env);
+        if (config.costBudget && config.costBudget.dailyLimit > 0) {
+            var dailySpend = getDailySpend();
+            if (dailySpend >= config.costBudget.dailyLimit) {
+                if (config.costBudget.enforcement === "hard-block") {
+                    sendTo(clientId, { type: "chat:error", message: "Daily cost budget exceeded ($" + dailySpend.toFixed(2) + " / $" + config.costBudget.dailyLimit.toFixed(2) + "). Sending is blocked until tomorrow." });
+                    return;
+                }
+                if (config.costBudget.enforcement === "soft-block") {
+                    pendingBudgetOverride.set(clientId, {
+                        projectSlug: active.projectSlug,
+                        sessionId: active.sessionId,
+                        sendMsg: sendMsg,
+                        env: Object.keys(env).length > 0 ? env : undefined,
+                        cwd: project.path,
+                    });
+                    sendTo(clientId, {
+                        type: "budget:exceeded",
+                        dailySpend: dailySpend,
+                        dailyLimit: config.costBudget.dailyLimit,
+                    });
+                    return;
+                }
+            }
+        }
+        var attachments = sendMsg.attachmentIds
+            ? getAttachments(clientId, sendMsg.attachmentIds)
+            : [];
+        startChatStream({
+            projectSlug: active.projectSlug,
+            sessionId: active.sessionId,
+            text: sendMsg.text,
+            attachments,
+            clientId,
+            cwd: project.path,
+            env: Object.keys(env).length > 0 ? env : undefined,
+            model: sendMsg.model,
+            effort: sendMsg.effort,
+        });
+        return;
+    }
+    if (message.type === "chat:cancel") {
+        var active = activeSessionByClient.get(clientId);
+        if (!active) {
+            sendTo(clientId, { type: "chat:error", message: "No active session." });
+            return;
+        }
+        var stream = getActiveStream(active.sessionId);
+        if (!stream) {
+            sendTo(clientId, { type: "chat:error", message: "No active stream to cancel." });
+            return;
+        }
+        stream.interrupt().catch(function () { });
+        return;
+    }
+    if (message.type === "chat:permission_response") {
+        var permMsg = message;
+        var pending = getPendingPermission(permMsg.requestId);
+        if (!pending) {
+            return;
+        }
+        var active = activeSessionByClient.get(clientId);
+        if (permMsg.allow) {
+            if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "session" && active) {
+                addAutoApprovedTool(active.sessionId, pending.toolName);
+            }
+            if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "project" && active) {
+                var project = getProjectBySlug(active.projectSlug);
+                if (project) {
+                    addProjectAllowRules(project.path, pending.suggestions, pending.toolName, pending.input);
+                }
+                pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
+            }
+            else {
+                pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
+            }
+            var resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
+            sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: resolvedStatus });
+        }
+        else {
+            pending.resolve({ behavior: "deny", message: "User denied this operation.", toolUseID: pending.toolUseID });
+            sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: "denied" });
+        }
+        deletePendingPermission(permMsg.requestId);
+        return;
+    }
+    if (message.type === "chat:prompt_response") {
+        var promptRespMsg = message;
+        var pendingPrompt = getPendingPermission(promptRespMsg.requestId);
+        if (!pendingPrompt || pendingPrompt.promptType !== "question") {
+            return;
+        }
+        var updatedInput = Object.assign({}, pendingPrompt.input, {
+            answers: promptRespMsg.answers,
+        });
+        if (promptRespMsg.annotations) {
+            updatedInput.annotations = promptRespMsg.annotations;
+        }
+        pendingPrompt.resolve({
+            behavior: "allow",
+            updatedInput: updatedInput,
+            toolUseID: pendingPrompt.toolUseID,
+        });
+        sendTo(clientId, { type: "chat:prompt_resolved", requestId: promptRespMsg.requestId });
+        deletePendingPermission(promptRespMsg.requestId);
+        return;
+    }
+    if (message.type === "chat:elicitation_response") {
+        var elicitMsg = message;
+        var pendingElicit = getPendingElicitation(elicitMsg.requestId);
+        if (!pendingElicit)
+            return;
+        resolveElicitation(elicitMsg.requestId, {
+            action: elicitMsg.action,
+            content: elicitMsg.content || {},
+        });
+        return;
+    }
+    if (message.type === "chat:rewind_preview") {
+        var rewindMsg = message;
+        var activeForRewind = activeSessionByClient.get(clientId);
+        if (!activeForRewind)
+            return;
+        var sessionStreamForRewind = getSessionStream(activeForRewind.sessionId);
+        if (!sessionStreamForRewind) {
+            sendTo(clientId, { type: "chat:rewind_preview_result", messageUuid: rewindMsg.messageUuid, canRewind: false, error: "No active stream for rewind" });
+            return;
+        }
+        void sessionStreamForRewind.queryInstance.rewindFiles(rewindMsg.messageUuid, { dryRun: true }).then(function (result) {
+            sendTo(clientId, {
+                type: "chat:rewind_preview_result",
+                messageUuid: rewindMsg.messageUuid,
+                canRewind: result.canRewind,
+                error: result.error,
+                filesChanged: (result.filesChanged || []).length,
+                filesCreated: 0,
+                filesDeleted: 0,
+            });
+        }).catch(function (err) {
+            sendTo(clientId, { type: "chat:rewind_preview_result", messageUuid: rewindMsg.messageUuid, canRewind: false, error: String(err) });
+        });
+        return;
+    }
+    if (message.type === "chat:rewind_execute") {
+        var execRewindMsg = message;
+        var activeForExec = activeSessionByClient.get(clientId);
+        if (!activeForExec)
+            return;
+        var sessionStreamForExec = getSessionStream(activeForExec.sessionId);
+        if (!sessionStreamForExec) {
+            sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: false, error: "No active stream" });
+            return;
+        }
+        if (execRewindMsg.mode === "files" || execRewindMsg.mode === "both") {
+            void sessionStreamForExec.queryInstance.rewindFiles(execRewindMsg.messageUuid, { dryRun: false }).then(function (result) {
+                sendTo(clientId, {
+                    type: "chat:rewind_execute_result",
+                    messageUuid: execRewindMsg.messageUuid,
+                    success: result.canRewind,
+                    error: result.error,
+                });
+            }).catch(function (err) {
+                sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: false, error: String(err) });
+            });
+        }
+        else {
+            sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: true });
+        }
+        return;
+    }
+    if (message.type === "chat:set_model") {
+        var modelMsg = message;
+        var activeSession = activeSessionByClient.get(clientId);
+        if (!activeSession)
+            return;
+        var sessionStream = getSessionStream(activeSession.sessionId);
+        if (sessionStream) {
+            void sessionStream.queryInstance.setModel(modelMsg.model === "default" ? undefined : modelMsg.model).catch(function (err) {
+                log.chat("Failed to switch model: %O", err);
+            });
+            sessionStream.currentModel = modelMsg.model;
+        }
+        return;
+    }
+    if (message.type === "chat:set_permission_mode") {
+        var modeMsg = message;
+        var activeSession = activeSessionByClient.get(clientId);
+        if (!activeSession) {
+            return;
+        }
+        var stream = getActiveStream(activeSession.sessionId);
+        if (stream) {
+            void stream.setPermissionMode(modeMsg.mode);
+        }
+        else {
+            setSessionPermissionOverride(activeSession.sessionId, modeMsg.mode);
+        }
+        return;
+    }
+});

package/dist/server/handlers/editor.js

@@ -0,0 +1,72 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { loadConfig } from "../config.js";
+import { loadOrCreateIdentity } from "../identity.js";
+import { broadcast } from "../ws/broadcast.js";
+import { detectIdeProjectName } from "./settings.js";
+var binaryNames = {
+    "vscode": ["code"],
+    "vscode-insiders": ["code-insiders"],
+    "cursor": ["cursor"],
+    "webstorm": ["webstorm", "webstorm.sh", "wstorm"],
+    "intellij": ["idea", "idea.sh"],
+    "pycharm": ["pycharm", "pycharm.sh", "charm"],
+    "goland": ["goland", "goland.sh"],
+    "notepad++": ["notepad++"],
+    "sublime": ["subl", "sublime_text"],
+};
+function detectEditorPath(editorType) {
+    var names = binaryNames[editorType];
+    if (!names)
+        return null;
+    for (var i = 0; i < names.length; i++) {
+        try {
+            var result = execSync("which " + names[i], { encoding: "utf-8", timeout: 3000 }).trim();
+            if (result)
+                return result;
+        }
+        catch {
+            // not found
+        }
+    }
+    return null;
+}
+function ensureIdeaProject(projectPath, projectTitle) {
+    var ideaDir = join(projectPath, ".idea");
+    if (!existsSync(ideaDir)) {
+        mkdirSync(ideaDir, { recursive: true });
+    }
+    var nameFile = join(ideaDir, ".name");
+    if (!existsSync(nameFile)) {
+        writeFileSync(nameFile, projectTitle, "utf-8");
+    }
+    return projectTitle;
+}
+registerHandler("editor", function (clientId, message) {
+    if (message.type === "editor:detect") {
+        var detectMsg = message;
+        var detectedPath = detectEditorPath(detectMsg.editorType);
+        sendTo(clientId, { type: "editor:detect_result", editorType: detectMsg.editorType, path: detectedPath });
+        return;
+    }
+    if (message.type === "editor:ensure-project") {
+        var ensureMsg = message;
+        var config = loadConfig();
+        var project = config.projects.find(function (p) { return p.slug === ensureMsg.projectSlug; });
+        if (project) {
+            var name = ensureIdeaProject(project.path, project.title);
+            sendTo(clientId, { type: "editor:ensure-project_result", projectSlug: ensureMsg.projectSlug, ideProjectName: name });
+            var identity = loadOrCreateIdentity();
+            broadcast({
+                type: "projects:list",
+                projects: config.projects.map(function (p) {
+                    return { slug: p.slug, path: p.path, title: p.title, nodeId: identity.id, nodeName: config.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path) };
+                }),
+            });
+        }
+        return;
+    }
+});