@cryptiklemur/lattice 4.0.2 → 5.0.0

package/dist/server/handlers/skills.js

@@ -0,0 +1,360 @@
+import { readdirSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync, spawn } from "node:child_process";
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { loadConfig } from "../config.js";
+import { readGlobalMcpServers, readGlobalSkills } from "../project/project-files.js";
+var searchCache = new Map();
+var skillsCache = null;
+var lastScanTime = 0;
+var CACHE_TTL_MS = 60000;
+function parseFrontmatter(content) {
+    var match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return { name: "", description: "" };
+    var yaml = match[1];
+    var name = "";
+    var desc = "";
+    var lines = yaml.split(/\r?\n/);
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        var nameMatch = line.match(/^name:\s*(.+)/);
+        if (nameMatch)
+            name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+        var descMatch = line.match(/^description:\s*(.+)/);
+        if (descMatch)
+            desc = descMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    return { name, description: desc };
+}
+function findSkillFiles(rootDir) {
+    if (!existsSync(rootDir))
+        return [];
+    try {
+        var output = execSync("find " + JSON.stringify(rootDir) + " -name SKILL.md -type f 2>/dev/null", { encoding: "utf-8", timeout: 5000 });
+        return output.trim().split("\n").filter(function (l) { return l.length > 0; });
+    }
+    catch {
+        return [];
+    }
+}
+function parseCommandFile(filePath, fileName) {
+    try {
+        var content = readFileSync(filePath, "utf-8");
+        var name = fileName.replace(/\.md$/, "");
+        var desc = "";
+        var lines = content.split(/\r?\n/);
+        for (var i = 0; i < Math.min(lines.length, 10); i++) {
+            var line = lines[i].trim();
+            if (line.length > 0 && !line.startsWith("#") && !line.startsWith("---")) {
+                desc = line.slice(0, 120);
+                break;
+            }
+        }
+        return { name: name, description: desc || "Command: " + name, path: filePath };
+    }
+    catch {
+        return null;
+    }
+}
+function scanCommandsDir(dirPath) {
+    var results = [];
+    if (!existsSync(dirPath))
+        return results;
+    try {
+        var entries = readdirSync(dirPath);
+        for (var i = 0; i < entries.length; i++) {
+            if (!entries[i].endsWith(".md"))
+                continue;
+            var filePath = join(dirPath, entries[i]);
+            var info = parseCommandFile(filePath, entries[i]);
+            if (info)
+                results.push(info);
+        }
+    }
+    catch { }
+    return results;
+}
+function getSkills() {
+    var now = Date.now();
+    if (skillsCache && now - lastScanTime < CACHE_TTL_MS) {
+        return skillsCache;
+    }
+    var home = homedir();
+    var skills = [];
+    var skillDirs = [
+        join(home, ".claude"),
+        join(home, ".agents"),
+        join(home, ".superpowers"),
+    ];
+    for (var d = 0; d < skillDirs.length; d++) {
+        var files = findSkillFiles(skillDirs[d]);
+        for (var f = 0; f < files.length; f++) {
+            try {
+                var content = readFileSync(files[f], "utf-8");
+                var meta = parseFrontmatter(content);
+                if (meta.name) {
+                    var skillName = meta.name;
+                    var filePath = files[f];
+                    var pluginMatch = filePath.match(/plugins\/([^/]+)\/skills\/([^/]+)\/SKILL\.md$/);
+                    if (pluginMatch) {
+                        var pluginName = pluginMatch[1];
+                        var rawSkillName = pluginMatch[2];
+                        if (skillName.indexOf(":") === -1 && skillName === rawSkillName) {
+                            skillName = pluginName + ":" + skillName;
+                        }
+                    }
+                    var extPluginMatch = filePath.match(/external_plugins\/([^/]+)\/skills\/([^/]+)\/SKILL\.md$/);
+                    if (extPluginMatch) {
+                        var extPluginName = extPluginMatch[1];
+                        var extSkillName = extPluginMatch[2];
+                        if (skillName.indexOf(":") === -1 && skillName === extSkillName) {
+                            skillName = extPluginName + ":" + skillName;
+                        }
+                    }
+                    var marketplaceSkillMatch = filePath.match(/marketplaces\/([^/]+)\/.claude\/skills\/([^/]+)\/SKILL\.md$/);
+                    if (marketplaceSkillMatch) {
+                        var mktName = marketplaceSkillMatch[1];
+                        var mktSkill = marketplaceSkillMatch[2];
+                        if (skillName.indexOf(":") === -1 && skillName === mktSkill) {
+                            skillName = mktName + ":" + skillName;
+                        }
+                    }
+                    skills.push({
+                        name: skillName,
+                        description: meta.description,
+                        path: filePath,
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    var config = loadConfig();
+    for (var p = 0; p < config.projects.length; p++) {
+        var projectPath = config.projects[p].path;
+        var projectSkillDirs = [
+            join(projectPath, ".claude", "skills"),
+            join(projectPath, ".claude", "commands"),
+            join(projectPath, ".superpowers", "skills"),
+        ];
+        for (var pd = 0; pd < projectSkillDirs.length; pd++) {
+            if (projectSkillDirs[pd].endsWith("commands")) {
+                var cmds = scanCommandsDir(projectSkillDirs[pd]);
+                for (var c = 0; c < cmds.length; c++)
+                    skills.push(cmds[c]);
+            }
+            else {
+                var projFiles = findSkillFiles(projectSkillDirs[pd]);
+                for (var pf = 0; pf < projFiles.length; pf++) {
+                    try {
+                        var projContent = readFileSync(projFiles[pf], "utf-8");
+                        var projMeta = parseFrontmatter(projContent);
+                        if (projMeta.name) {
+                            skills.push({
+                                name: projMeta.name,
+                                description: projMeta.description,
+                                path: projFiles[pf],
+                            });
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    var globalCommands = scanCommandsDir(join(home, ".claude", "commands"));
+    for (var gc = 0; gc < globalCommands.length; gc++) {
+        skills.push(globalCommands[gc]);
+    }
+    var namespacedBareNames = new Set();
+    for (var n = 0; n < skills.length; n++) {
+        var colonIdx = skills[n].name.indexOf(":");
+        if (colonIdx !== -1) {
+            namespacedBareNames.add(skills[n].name.slice(colonIdx + 1));
+        }
+    }
+    var filtered = [];
+    for (var fi = 0; fi < skills.length; fi++) {
+        if (skills[fi].name.indexOf(":") === -1 && namespacedBareNames.has(skills[fi].name)) {
+            continue;
+        }
+        filtered.push(skills[fi]);
+    }
+    filtered.sort(function (a, b) { return a.name.localeCompare(b.name); });
+    var seen = new Set();
+    var unique = [];
+    for (var i = 0; i < filtered.length; i++) {
+        if (!seen.has(filtered[i].name)) {
+            seen.add(filtered[i].name);
+            unique.push(filtered[i]);
+        }
+    }
+    skillsCache = unique;
+    lastScanTime = now;
+    return unique;
+}
+export function resolveSkillContent(skillName) {
+    var skills = getSkills();
+    var match = skills.find(function (s) { return s.name === skillName; });
+    if (!match)
+        return null;
+    try {
+        return readFileSync(match.path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+registerHandler("skills", function (clientId, message) {
+    if (message.type === "skills:list_request") {
+        var skills = getSkills();
+        sendTo(clientId, { type: "skills:list", skills: skills });
+        return;
+    }
+    if (message.type === "skills:search") {
+        var searchMsg = message;
+        var query = searchMsg.query.trim();
+        if (!query) {
+            sendTo(clientId, { type: "skills:search_results", query: query, skills: [], count: 0 });
+            return;
+        }
+        var cacheKey = "search:" + query;
+        var cached = searchCache.get(cacheKey);
+        if (cached && Date.now() - cached.time < 60000) {
+            sendTo(clientId, { type: "skills:search_results", query: query, skills: cached.skills, count: cached.count });
+            return;
+        }
+        void fetch("https://skills.sh/api/search?q=" + encodeURIComponent(query))
+            .then(function (res) { return res.json(); })
+            .then(function (data) {
+            var skills = (data.skills ?? []).map(function (s) {
+                return { id: s.id, skillId: s.skillId, name: s.name, source: s.source, installs: s.installs };
+            });
+            var count = data.count ?? skills.length;
+            searchCache.set(cacheKey, { skills: skills, count: count, time: Date.now() });
+            sendTo(clientId, { type: "skills:search_results", query: query, skills: skills, count: count });
+        })
+            .catch(function () {
+            sendTo(clientId, { type: "skills:search_results", query: query, skills: [], count: 0, error: "Search unavailable" });
+        });
+        return;
+    }
+    if (message.type === "skills:install") {
+        var installMsg = message;
+        var cwd = homedir();
+        if (installMsg.scope === "project" && installMsg.projectSlug) {
+            var installConfig = loadConfig();
+            var installProject = installConfig.projects.find(function (p) { return p.slug === installMsg.projectSlug; });
+            if (installProject) {
+                cwd = installProject.path;
+            }
+        }
+        try {
+            var proc = spawn("npx", ["skillsadd", installMsg.source], {
+                cwd: cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            var timeout = setTimeout(function () {
+                proc.kill();
+            }, 60000);
+            proc.on("close", function (code) {
+                clearTimeout(timeout);
+                skillsCache = null;
+                if (code === 0) {
+                    sendTo(clientId, { type: "skills:install_result", success: true, message: "Installed successfully" });
+                }
+                else {
+                    sendTo(clientId, { type: "skills:install_result", success: false, message: "Install failed (exit code " + code + ")" });
+                }
+                if (installMsg.scope === "global") {
+                    var globalConfig = loadConfig();
+                    sendTo(clientId, {
+                        type: "settings:data",
+                        config: globalConfig,
+                        mcpServers: readGlobalMcpServers(),
+                        globalSkills: readGlobalSkills(),
+                    });
+                }
+            });
+        }
+        catch (err) {
+            sendTo(clientId, { type: "skills:install_result", success: false, message: "Failed to start install: " + String(err) });
+        }
+        return;
+    }
+    if (message.type === "skills:view") {
+        var viewMsg = message;
+        try {
+            if (!existsSync(viewMsg.path)) {
+                sendTo(clientId, { type: "skills:view_result", path: viewMsg.path, content: "File not found." });
+                return;
+            }
+            var viewContent = readFileSync(viewMsg.path, "utf-8");
+            sendTo(clientId, { type: "skills:view_result", path: viewMsg.path, content: viewContent });
+        }
+        catch {
+            sendTo(clientId, { type: "skills:view_result", path: viewMsg.path, content: "Failed to read file." });
+        }
+        return;
+    }
+    if (message.type === "skills:delete") {
+        var deleteMsg = message;
+        try {
+            var skillDir = dirname(deleteMsg.path);
+            if (!existsSync(deleteMsg.path)) {
+                sendTo(clientId, { type: "skills:delete_result", success: false, message: "Skill not found." });
+                return;
+            }
+            rmSync(skillDir, { recursive: true, force: true });
+            skillsCache = null;
+            sendTo(clientId, { type: "skills:delete_result", success: true, message: "Skill deleted." });
+            var delConfig = loadConfig();
+            sendTo(clientId, {
+                type: "settings:data",
+                config: delConfig,
+                mcpServers: readGlobalMcpServers(),
+                globalSkills: readGlobalSkills(),
+            });
+        }
+        catch (err) {
+            sendTo(clientId, { type: "skills:delete_result", success: false, message: "Failed to delete: " + String(err) });
+        }
+        return;
+    }
+    if (message.type === "skills:update") {
+        var updateMsg = message;
+        try {
+            var updateProc = spawn("npx", ["skillsadd", updateMsg.source], {
+                cwd: homedir(),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            var updateTimeout = setTimeout(function () {
+                updateProc.kill();
+            }, 60000);
+            updateProc.on("close", function (code) {
+                clearTimeout(updateTimeout);
+                skillsCache = null;
+                if (code === 0) {
+                    sendTo(clientId, { type: "skills:install_result", success: true, message: "Updated successfully" });
+                }
+                else {
+                    sendTo(clientId, { type: "skills:install_result", success: false, message: "Update failed (exit code " + code + ")" });
+                }
+                var updConfig = loadConfig();
+                sendTo(clientId, {
+                    type: "settings:data",
+                    config: updConfig,
+                    mcpServers: readGlobalMcpServers(),
+                    globalSkills: readGlobalSkills(),
+                });
+            });
+        }
+        catch (err) {
+            sendTo(clientId, { type: "skills:install_result", success: false, message: "Failed to start update: " + String(err) });
+        }
+        return;
+    }
+});

package/dist/server/handlers/terminal.js

@@ -0,0 +1,75 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { createTerminal, destroyTerminal, writeToTerminal, resizeTerminal } from "../project/terminal.js";
+import { getActiveSession } from "./chat.js";
+import { getProjectBySlug } from "../project/registry.js";
+import { homedir } from "node:os";
+var clientTerminals = new Map();
+function getOrCreateClientSet(clientId) {
+    var set = clientTerminals.get(clientId);
+    if (!set) {
+        set = new Set();
+        clientTerminals.set(clientId, set);
+    }
+    return set;
+}
+export function cleanupClientTerminals(clientId) {
+    var set = clientTerminals.get(clientId);
+    if (set) {
+        set.forEach(function (termId) {
+            destroyTerminal(termId);
+        });
+        clientTerminals.delete(clientId);
+    }
+}
+registerHandler("terminal", function (clientId, message) {
+    if (message.type === "terminal:create") {
+        var createMsg = message;
+        var cwd = homedir();
+        if (createMsg.projectSlug) {
+            var slugProject = getProjectBySlug(createMsg.projectSlug);
+            if (slugProject) {
+                cwd = slugProject.path;
+            }
+        }
+        else {
+            var active = getActiveSession(clientId);
+            if (active) {
+                var project = getProjectBySlug(active.projectSlug);
+                if (project) {
+                    cwd = project.path;
+                }
+            }
+        }
+        var termId = createTerminal(cwd, function (data) {
+            sendTo(clientId, { type: "terminal:output", termId: termId, data: data });
+        }, function (code) {
+            sendTo(clientId, { type: "terminal:exited", termId: termId, code: code });
+            getOrCreateClientSet(clientId).delete(termId);
+        });
+        getOrCreateClientSet(clientId).add(termId);
+        sendTo(clientId, { type: "terminal:created", termId: termId });
+        return;
+    }
+    if (message.type === "terminal:input") {
+        var inputMsg = message;
+        var clientSet = clientTerminals.get(clientId);
+        if (!clientSet || !clientSet.has(inputMsg.termId)) {
+            return;
+        }
+        if (typeof inputMsg.data === "string" && inputMsg.data.length > 65536) {
+            return;
+        }
+        writeToTerminal(inputMsg.termId, inputMsg.data);
+        return;
+    }
+    if (message.type === "terminal:resize") {
+        var resizeMsg = message;
+        var resizeClientSet = clientTerminals.get(clientId);
+        if (!resizeClientSet || !resizeClientSet.has(resizeMsg.termId)) {
+            return;
+        }
+        resizeTerminal(resizeMsg.termId, resizeMsg.cols, resizeMsg.rows);
+        return;
+    }
+});

package/dist/server/handlers/themes.js

@@ -0,0 +1,102 @@
+import { join } from "node:path";
+import { readdir, readFile, writeFile, unlink, mkdir } from "node:fs/promises";
+import { registerHandler } from "../ws/router.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
+import { getLatticeHome } from "../config.js";
+function themesDir() {
+    return join(getLatticeHome(), "themes");
+}
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+async function ensureThemesDir() {
+    await mkdir(themesDir(), { recursive: true });
+}
+async function loadAllThemes() {
+    await ensureThemesDir();
+    var dir = themesDir();
+    var files = await readdir(dir);
+    var jsonFiles = files.filter((f) => f.endsWith(".json"));
+    var themes = [];
+    for (var file of jsonFiles) {
+        try {
+            var raw = await readFile(join(dir, file), "utf-8");
+            var data = JSON.parse(raw);
+            var colors = {};
+            for (var key of Object.keys(data)) {
+                if (key.startsWith("base0")) {
+                    colors[key] = data[key];
+                }
+            }
+            themes.push({
+                name: data.name ?? file.replace(/\.json$/, ""),
+                author: data.author ?? "",
+                variant: data.variant ?? "dark",
+                filename: file,
+                colors,
+            });
+        }
+        catch {
+            // skip malformed files
+        }
+    }
+    return themes;
+}
+registerHandler("theme", async function (clientId, message) {
+    if (message.type === "theme:list_custom") {
+        var themes = await loadAllThemes();
+        sendTo(clientId, { type: "theme:custom_list", themes });
+        return;
+    }
+    if (message.type === "theme:save") {
+        var saveMsg = message;
+        var slug = slugify(saveMsg.name);
+        var filename = slug + ".json";
+        var themeData = {
+            name: saveMsg.name,
+            author: saveMsg.author,
+            variant: saveMsg.variant,
+            ...saveMsg.colors,
+        };
+        await ensureThemesDir();
+        await writeFile(join(themesDir(), filename), JSON.stringify(themeData, null, 2));
+        var savedColors = {};
+        for (var key of Object.keys(saveMsg.colors)) {
+            if (key.startsWith("base0")) {
+                savedColors[key] = saveMsg.colors[key];
+            }
+        }
+        sendTo(clientId, {
+            type: "theme:saved",
+            theme: {
+                name: saveMsg.name,
+                author: saveMsg.author,
+                variant: saveMsg.variant,
+                filename,
+                colors: savedColors,
+            },
+        });
+        var allThemes = await loadAllThemes();
+        broadcast({ type: "theme:custom_list", themes: allThemes });
+        return;
+    }
+    if (message.type === "theme:delete") {
+        var deleteMsg = message;
+        var deleteSlug = slugify(deleteMsg.name);
+        var deleteFilename = deleteSlug + ".json";
+        try {
+            await unlink(join(themesDir(), deleteFilename));
+        }
+        catch {
+            sendTo(clientId, { type: "chat:error", message: "Theme file not found" });
+            return;
+        }
+        sendTo(clientId, { type: "theme:deleted", filename: deleteFilename });
+        var updatedThemes = await loadAllThemes();
+        broadcast({ type: "theme:custom_list", themes: updatedThemes });
+        return;
+    }
+});

package/dist/server/handlers/update.js

@@ -0,0 +1,124 @@
+import { chmodSync, writeFileSync, accessSync, copyFileSync, unlinkSync, constants as fsConstants } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execSync, spawn } from "node:child_process";
+import { registerHandler } from "../ws/router.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
+import { checkForUpdate, getPackageName, getGitHubRepo } from "../update-checker.js";
+function getAssetName() {
+    var platform = process.platform === "darwin" ? "darwin" : "linux";
+    var arch = process.arch === "arm64" ? "arm64" : "x64";
+    return "lattice-" + platform + "-" + arch;
+}
+async function downloadBinaryUpdate() {
+    var repo = getGitHubRepo();
+    var assetName = getAssetName();
+    try {
+        var releaseRes = await fetch("https://api.github.com/repos/" + repo + "/releases/latest", {
+            headers: { "Accept": "application/vnd.github.v3+json" },
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!releaseRes.ok) {
+            return { success: false, message: "Failed to fetch release info (HTTP " + releaseRes.status + ")" };
+        }
+        var release = await releaseRes.json();
+        var assets = release.assets ?? [];
+        var asset = assets.find(function (a) { return a.name === assetName; });
+        if (!asset) {
+            return { success: false, message: "No binary found for " + assetName + " in latest release" };
+        }
+        var downloadRes = await fetch(asset.browser_download_url, {
+            signal: AbortSignal.timeout(120000),
+        });
+        if (!downloadRes.ok) {
+            return { success: false, message: "Failed to download binary (HTTP " + downloadRes.status + ")" };
+        }
+        var binary = new Uint8Array(await downloadRes.arrayBuffer());
+        var execPath = process.execPath;
+        var tmpPath = join(tmpdir(), "lattice-update-" + Date.now());
+        writeFileSync(tmpPath, binary);
+        chmodSync(tmpPath, 0o755);
+        var needsSudo = false;
+        try {
+            accessSync(execPath, fsConstants.W_OK);
+        }
+        catch {
+            needsSudo = true;
+        }
+        if (needsSudo) {
+            try {
+                execSync("sudo cp " + JSON.stringify(tmpPath) + " " + JSON.stringify(execPath), { stdio: "pipe", timeout: 10000 });
+                execSync("sudo chmod +x " + JSON.stringify(execPath), { stdio: "pipe", timeout: 5000 });
+                unlinkSync(tmpPath);
+            }
+            catch {
+                return { success: false, message: "Update downloaded but needs sudo to install. Run: sudo cp " + tmpPath + " " + execPath };
+            }
+        }
+        else {
+            try {
+                unlinkSync(execPath);
+            }
+            catch { }
+            copyFileSync(tmpPath, execPath);
+            chmodSync(execPath, 0o755);
+            unlinkSync(tmpPath);
+        }
+        return { success: true, message: "Updated successfully. Restart the server to apply." };
+    }
+    catch (err) {
+        return { success: false, message: "Update failed: " + (err instanceof Error ? err.message : String(err)) };
+    }
+}
+registerHandler("update", function (clientId, message) {
+    if (message.type === "update:check") {
+        var checkMsg = message;
+        void checkForUpdate(checkMsg.force ?? false).then(function (info) {
+            sendTo(clientId, {
+                type: "update:status",
+                currentVersion: info.currentVersion,
+                latestVersion: info.latestVersion,
+                updateAvailable: info.updateAvailable,
+                releaseUrl: info.releaseUrl,
+                installMode: info.installMode,
+            });
+        });
+        return;
+    }
+    if (message.type === "update:apply") {
+        {
+            var pkgName = getPackageName();
+            try {
+                var proc = spawn("npm", ["install", "-g", pkgName + "@latest"], {
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                var timeout = setTimeout(function () {
+                    proc.kill();
+                }, 120000);
+                proc.on("close", function (code) {
+                    clearTimeout(timeout);
+                    if (code === 0) {
+                        sendTo(clientId, { type: "update:apply_result", success: true, message: "Updated successfully. Restart the server to apply." });
+                        void checkForUpdate(true).then(function (info) {
+                            broadcast({
+                                type: "update:status",
+                                currentVersion: info.currentVersion,
+                                latestVersion: info.latestVersion,
+                                updateAvailable: info.updateAvailable,
+                                releaseUrl: info.releaseUrl,
+                                installMode: info.installMode,
+                            });
+                        });
+                    }
+                    else {
+                        sendTo(clientId, { type: "update:apply_result", success: false, message: "Update failed (exit code " + code + ")" });
+                    }
+                });
+            }
+            catch (err) {
+                sendTo(clientId, { type: "update:apply_result", success: false, message: "Failed to start update: " + String(err) });
+            }
+        }
+        return;
+    }
+});