@cryptiklemur/lattice 0.0.0

package/server/src/handlers/skills.ts

@@ -0,0 +1,380 @@
+import { readdirSync, readFileSync, existsSync, lstatSync, realpathSync, statSync, rmSync } from "node:fs";
+import { join, sep, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import type { ClientMessage } from "@lattice/shared";
+import type { SkillInfo } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { loadConfig } from "../config";
+import { readGlobalMcpServers, readGlobalSkills } from "../project/project-files";
+
+var searchCache = new Map<string, { skills: Array<{ id: string; skillId: string; name: string; source: string; installs: number }>; count: number; time: number }>();
+
+var skillsCache: SkillInfo[] | null = null;
+var lastScanTime: number = 0;
+var CACHE_TTL_MS = 60000;
+
+function parseFrontmatter(content: string): { name: string; description: string } {
+  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: string): string[] {
+  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: string, fileName: string): SkillInfo | null {
+  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: string): SkillInfo[] {
+  var results: SkillInfo[] = [];
+  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(): SkillInfo[] {
+  var now = Date.now();
+  if (skillsCache && now - lastScanTime < CACHE_TTL_MS) {
+    return skillsCache;
+  }
+
+  var home = homedir();
+  var skills: SkillInfo[] = [];
+
+  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<string>();
+  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: SkillInfo[] = [];
+  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<string>();
+  var unique: SkillInfo[] = [];
+  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: string): string | null {
+  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: string, message: ClientMessage) {
+  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 as { type: "skills:search"; query: string };
+    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: { skills?: Array<{ id: string; skillId: string; name: string; source: string; installs: number }>; count?: number }) {
+        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 as { type: "skills:install"; source: string; scope: "global" | "project"; projectSlug?: string };
+    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 = Bun.spawn(["npx", "skillsadd", installMsg.source], {
+        cwd: cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      var timeout = setTimeout(function () {
+        proc.kill();
+      }, 60000);
+
+      void proc.exited.then(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() as Record<string, import("@lattice/shared").McpServerConfig>,
+            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 as { type: "skills:view"; path: string };
+    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 as { type: "skills:delete"; path: string };
+    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() as Record<string, import("@lattice/shared").McpServerConfig>,
+        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 as { type: "skills:update"; source: string };
+    try {
+      var updateProc = Bun.spawn(["npx", "skillsadd", updateMsg.source], {
+        cwd: homedir(),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      var updateTimeout = setTimeout(function () {
+        updateProc.kill();
+      }, 60000);
+
+      void updateProc.exited.then(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() as Record<string, import("@lattice/shared").McpServerConfig>,
+          globalSkills: readGlobalSkills(),
+        });
+      });
+    } catch (err) {
+      sendTo(clientId, { type: "skills:install_result", success: false, message: "Failed to start update: " + String(err) });
+    }
+    return;
+  }
+});

package/server/src/handlers/terminal.ts

@@ -0,0 +1,70 @@
+import type { ClientMessage, TerminalCreateMessage, TerminalInputMessage, TerminalResizeMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { createTerminal, destroyTerminal, writeToTerminal, resizeTerminal } from "../project/terminal";
+import { getActiveSession } from "./chat";
+import { getProjectBySlug } from "../project/registry";
+import { homedir } from "node:os";
+
+var clientTerminals = new Map<string, Set<string>>();
+
+function getOrCreateClientSet(clientId: string): Set<string> {
+  var set = clientTerminals.get(clientId);
+  if (!set) {
+    set = new Set<string>();
+    clientTerminals.set(clientId, set);
+  }
+  return set;
+}
+
+export function cleanupClientTerminals(clientId: string): void {
+  var set = clientTerminals.get(clientId);
+  if (set) {
+    set.forEach(function(termId) {
+      destroyTerminal(termId);
+    });
+    clientTerminals.delete(clientId);
+  }
+}
+
+registerHandler("terminal", function(clientId: string, message: ClientMessage) {
+  if (message.type === "terminal:create") {
+    var _msg = message as TerminalCreateMessage;
+    var cwd = homedir();
+
+    var active = getActiveSession(clientId);
+    if (active) {
+      var project = getProjectBySlug(active.projectSlug);
+      if (project) {
+        cwd = project.path;
+      }
+    }
+
+    var termId = createTerminal(
+      cwd,
+      function(data: string) {
+        sendTo(clientId, { type: "terminal:output", termId: termId, data: data });
+      },
+      function(code: number) {
+        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 as TerminalInputMessage;
+    writeToTerminal(inputMsg.termId, inputMsg.data);
+    return;
+  }
+
+  if (message.type === "terminal:resize") {
+    var resizeMsg = message as TerminalResizeMessage;
+    resizeTerminal(resizeMsg.termId, resizeMsg.cols, resizeMsg.rows);
+    return;
+  }
+});

package/server/src/identity.ts

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { getLatticeHome } from "./config";
+
+interface NodeIdentity {
+  id: string;
+  createdAt: number;
+}
+
+export function getIdentityPath(): string {
+  return join(getLatticeHome(), "identity.json");
+}
+
+export function loadOrCreateIdentity(): NodeIdentity {
+  var path = getIdentityPath();
+  if (existsSync(path)) {
+    return JSON.parse(readFileSync(path, "utf-8")) as NodeIdentity;
+  }
+  var identity: NodeIdentity = {
+    id: randomUUID(),
+    createdAt: Date.now(),
+  };
+  writeFileSync(path, JSON.stringify(identity, null, 2), "utf-8");
+  return identity;
+}

package/server/src/index.ts

@@ -0,0 +1,190 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { DAEMON_PID_FILE } from "@lattice/shared";
+import { getLatticeHome, loadConfig } from "./config";
+
+var args = process.argv.slice(2);
+var command = "start";
+var portOverride: number | null = null;
+
+for (var i = 0; i < args.length; i++) {
+  if (args[i] === "--port" && i + 1 < args.length) {
+    portOverride = parseInt(args[i + 1], 10);
+    i++;
+  } else if (args[i].startsWith("--port=")) {
+    portOverride = parseInt(args[i].split("=")[1], 10);
+  } else if (!args[i].startsWith("-")) {
+    command = args[i];
+  }
+}
+
+function getPidPath(): string {
+  return join(getLatticeHome(), DAEMON_PID_FILE);
+}
+
+function readPid(): number | null {
+  var pidPath = getPidPath();
+  if (!existsSync(pidPath)) {
+    return null;
+  }
+  try {
+    var raw = readFileSync(pidPath, "utf-8").trim();
+    var pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+function writePid(pid: number): void {
+  writeFileSync(getPidPath(), String(pid), "utf-8");
+}
+
+function removePid(): void {
+  var pidPath = getPidPath();
+  if (existsSync(pidPath)) {
+    try {
+      unlinkSync(pidPath);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function isDaemonRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+switch (command) {
+  case "daemon":
+    await runDaemon();
+    break;
+  case "start":
+    await runStart();
+    break;
+  case "stop":
+    runStop();
+    break;
+  case "status":
+    runStatus();
+    break;
+  default:
+    console.log("[lattice] Unknown command: " + command);
+    console.log("[lattice] Usage: lattice [start|stop|status|daemon]");
+    process.exit(1);
+}
+
+async function runDaemon(): Promise<void> {
+  var { startDaemon } = await import("./daemon");
+  writePid(process.pid);
+  process.on("SIGTERM", function () {
+    removePid();
+    process.exit(0);
+  });
+  process.on("SIGINT", function () {
+    removePid();
+    process.exit(0);
+  });
+  await startDaemon(portOverride);
+}
+
+async function runStart(): Promise<void> {
+  var pid = readPid();
+  if (pid !== null && isDaemonRunning(pid)) {
+    console.log("[lattice] Daemon is already running (PID " + pid + ")");
+    var config = loadConfig();
+    var url = (config.tls ? "https" : "http") + "://localhost:" + config.port;
+    openBrowser(url);
+    return;
+  }
+
+  removePid();
+
+  var scriptPath = import.meta.path;
+  var logPath = join(getLatticeHome(), "daemon.log");
+
+  var child = Bun.spawn(["bun", scriptPath, "daemon"], {
+    detached: true,
+    stdio: ["ignore", Bun.file(logPath), Bun.file(logPath)],
+  });
+
+  child.unref();
+
+  var childPid = child.pid;
+  writePid(childPid);
+  console.log("[lattice] Daemon started (PID " + childPid + ")");
+  console.log("[lattice] Logs: " + logPath);
+
+  await new Promise<void>(function (resolve) {
+    setTimeout(resolve, 800);
+  });
+
+  var config = loadConfig();
+  var url = (config.tls ? "https" : "http") + "://localhost:" + config.port;
+  console.log("[lattice] Opening " + url);
+  openBrowser(url);
+}
+
+function runStop(): void {
+  var pid = readPid();
+  if (pid === null) {
+    console.log("[lattice] No PID file found. Daemon may not be running.");
+    process.exit(1);
+  }
+
+  if (!isDaemonRunning(pid)) {
+    console.log("[lattice] Daemon is not running (stale PID " + pid + ")");
+    removePid();
+    process.exit(0);
+  }
+
+  try {
+    process.kill(pid, "SIGTERM");
+    removePid();
+    console.log("[lattice] Daemon stopped (PID " + pid + ")");
+  } catch (err) {
+    console.error("[lattice] Failed to stop daemon:", err);
+    process.exit(1);
+  }
+}
+
+function runStatus(): void {
+  var pid = readPid();
+  if (pid === null) {
+    console.log("[lattice] Status: not running (no PID file)");
+    process.exit(0);
+  }
+
+  if (!isDaemonRunning(pid)) {
+    console.log("[lattice] Status: not running (stale PID " + pid + ")");
+    removePid();
+    process.exit(0);
+  }
+
+  var config = loadConfig();
+  var url = (config.tls ? "https" : "http") + "://localhost:" + config.port;
+  console.log("[lattice] Status: running");
+  console.log("[lattice] PID:    " + pid);
+  console.log("[lattice] Port:   " + config.port);
+  console.log("[lattice] URL:    " + url);
+}
+
+function openBrowser(url: string): void {
+  var platform = process.platform;
+  try {
+    if (platform === "win32") {
+      Bun.spawn(["cmd", "/c", "start", url], { detached: true, stdio: ["ignore", "ignore", "ignore"] }).unref();
+    } else if (platform === "darwin") {
+      Bun.spawn(["open", url], { detached: true, stdio: ["ignore", "ignore", "ignore"] }).unref();
+    } else {
+      Bun.spawn(["xdg-open", url], { detached: true, stdio: ["ignore", "ignore", "ignore"] }).unref();
+    }
+  } catch {
+    console.log("[lattice] Could not open browser. Visit: " + url);
+  }
+}