@cryptiklemur/lattice 0.0.0

package/server/src/handlers/mesh.ts

@@ -0,0 +1,125 @@
+import type { ClientMessage, MeshPairMessage, MeshUnpairMessage, NodeInfo } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { loadConfig } from "../config";
+import { loadOrCreateIdentity } from "../identity";
+import { generateInviteCode, parseInviteCode, validatePairingToken, consumePairingToken } from "../mesh/pairing";
+import { addPeer, removePeer, loadPeers } from "../mesh/peers";
+import type { PeerInfo } from "@lattice/shared";
+
+export function buildNodesMessage(): NodeInfo[] {
+  var peers = loadPeers();
+  var config = loadConfig();
+  var identity = loadOrCreateIdentity();
+
+  var local: NodeInfo = {
+    id: identity.id,
+    name: config.name,
+    address: "localhost",
+    port: config.port,
+    online: true,
+    isLocal: true,
+    projects: config.projects.map(function (p) {
+      return { slug: p.slug, path: p.path, title: p.title, nodeId: identity.id };
+    }),
+  };
+
+  var remotes: NodeInfo[] = peers.map(function (peer) {
+    return {
+      id: peer.id,
+      name: peer.name,
+      address: peer.addresses[0] ?? "",
+      port: 0,
+      online: false,
+      isLocal: false,
+      projects: [],
+    };
+  });
+
+  return [local, ...remotes];
+}
+
+registerHandler("mesh", function (clientId: string, message: ClientMessage) {
+  if (message.type === "mesh:generate_invite") {
+    var config = loadConfig();
+    generateInviteCode("localhost", config.port).then(function (result) {
+      sendTo(clientId, {
+        type: "mesh:invite_code",
+        code: result.code,
+        qrDataUrl: result.qrDataUrl,
+      });
+    }).catch(function (err) {
+      console.error("[lattice] Failed to generate invite code:", err);
+    });
+    return;
+  }
+
+  if (message.type === "mesh:pair") {
+    var pairMsg = message as MeshPairMessage;
+    var parsed = parseInviteCode(pairMsg.code);
+    if (!parsed) {
+      console.warn("[lattice] mesh:pair — invalid invite code");
+      return;
+    }
+    if (!validatePairingToken(parsed.token)) {
+      console.warn("[lattice] mesh:pair — invalid or expired token");
+      return;
+    }
+    consumePairingToken(parsed.token);
+
+    var wsUrl = "ws://" + parsed.address + ":" + parsed.port + "/ws";
+    var ws = new WebSocket(wsUrl);
+    ws.addEventListener("open", function () {
+      var identity = loadOrCreateIdentity();
+      ws.send(JSON.stringify({
+        type: "mesh:hello",
+        nodeId: identity.id,
+        name: loadConfig().name,
+        projects: [],
+      }));
+    });
+    ws.addEventListener("message", function (event: MessageEvent) {
+      try {
+        var data = JSON.parse(event.data as string) as { type: string; nodeId?: string; name?: string };
+        if (data.type === "mesh:hello" && data.nodeId && data.name) {
+          var peer: PeerInfo = {
+            id: data.nodeId,
+            name: data.name,
+            addresses: [parsed!.address],
+            publicKey: "",
+            pairedAt: Date.now(),
+          };
+          addPeer(peer);
+          ws.close();
+
+          var nodeInfo: NodeInfo = {
+            id: peer.id,
+            name: peer.name,
+            address: parsed!.address,
+            port: parsed!.port,
+            online: true,
+            isLocal: false,
+            projects: [],
+          };
+          sendTo(clientId, { type: "mesh:paired", node: nodeInfo });
+          broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+        }
+      } catch {
+        console.error("[lattice] mesh:pair — invalid handshake response");
+      }
+    });
+    ws.addEventListener("error", function () {
+      console.error("[lattice] mesh:pair — failed to connect to", wsUrl);
+    });
+    return;
+  }
+
+  if (message.type === "mesh:unpair") {
+    var unpairMsg = message as MeshUnpairMessage;
+    var removed = removePeer(unpairMsg.nodeId);
+    if (removed) {
+      broadcast({ type: "mesh:nodes", nodes: buildNodesMessage() });
+    }
+    return;
+  }
+});

package/server/src/handlers/notes.ts

@@ -0,0 +1,45 @@
+import type {
+  ClientMessage,
+  NotesCreateMessage,
+  NotesUpdateMessage,
+  NotesDeleteMessage,
+} from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { listNotes, createNote, updateNote, deleteNote } from "../features/sticky-notes";
+
+registerHandler("notes", function (clientId: string, message: ClientMessage) {
+  if (message.type === "notes:list") {
+    sendTo(clientId, { type: "notes:list_result", notes: listNotes() });
+    return;
+  }
+
+  if (message.type === "notes:create") {
+    var createMsg = message as NotesCreateMessage;
+    var note = createNote(createMsg.content);
+    broadcast({ type: "notes:created", note });
+    return;
+  }
+
+  if (message.type === "notes:update") {
+    var updateMsg = message as NotesUpdateMessage;
+    var updated = updateNote(updateMsg.id, updateMsg.content);
+    if (!updated) {
+      sendTo(clientId, { type: "chat:error", message: "Note not found" });
+      return;
+    }
+    broadcast({ type: "notes:updated", note: updated });
+    return;
+  }
+
+  if (message.type === "notes:delete") {
+    var deleteMsg = message as NotesDeleteMessage;
+    var deleted = deleteNote(deleteMsg.id);
+    if (!deleted) {
+      sendTo(clientId, { type: "chat:error", message: "Note not found" });
+      return;
+    }
+    broadcast({ type: "notes:deleted", id: deleteMsg.id });
+    return;
+  }
+});

package/server/src/handlers/project-settings.ts

@@ -0,0 +1,174 @@
+import type { ClientMessage, ProjectSettingsGetMessage, ProjectSettingsUpdateMessage, ProjectSettings, McpServerConfig } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { loadConfig, saveConfig, invalidateConfigCache } from "../config";
+import { getProjectBySlug } from "../project/registry";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import {
+  readProjectClaudeMd,
+  writeProjectClaudeMd,
+  readProjectClaudeSettings,
+  mergeProjectClaudeSettings,
+  readProjectRules,
+  writeProjectRules,
+  readProjectMcpServers,
+  writeProjectMcpServers,
+  readProjectSkills,
+  readGlobalRules,
+  readGlobalPermissions,
+  readGlobalMcpServers,
+  readGlobalSkills,
+} from "../project/project-files";
+
+function loadGlobalClaudeMd(): string {
+  var mdPath = join(homedir(), ".claude", "CLAUDE.md");
+  if (existsSync(mdPath)) {
+    try {
+      return readFileSync(mdPath, "utf-8");
+    } catch {}
+  }
+  return "";
+}
+
+function buildProjectSettings(projectSlug: string): ProjectSettings | { error: string } {
+  var project = getProjectBySlug(projectSlug);
+  if (!project) {
+    return { error: "Project not found" };
+  }
+  if (!existsSync(project.path)) {
+    return { error: "Project path does not exist on disk" };
+  }
+
+  var claudeMd = readProjectClaudeMd(project.path);
+  var claudeSettings = readProjectClaudeSettings(project.path);
+  var lattice = (claudeSettings.lattice ?? {}) as Record<string, unknown>;
+  var permissions = (claudeSettings.permissions ?? { allow: [], deny: [] }) as { allow: string[]; deny: string[] };
+  var rules = readProjectRules(project.path);
+  var mcpServers = readProjectMcpServers(project.path) as Record<string, McpServerConfig>;
+  var skills = readProjectSkills(project.path);
+
+  var config = loadConfig();
+
+  var settings: ProjectSettings = {
+    title: project.title,
+    path: project.path,
+    icon: (project as Record<string, unknown>).icon as ProjectSettings["icon"],
+    claudeMd,
+    defaultModel: (lattice.defaultModel as string) || undefined,
+    defaultEffort: (lattice.defaultEffort as string) || undefined,
+    thinking: lattice.thinking as ProjectSettings["thinking"],
+    permissionMode: (lattice.defaultPermissionMode as string) || undefined,
+    permissions: {
+      allow: Array.isArray(permissions.allow) ? permissions.allow : [],
+      deny: Array.isArray(permissions.deny) ? permissions.deny : [],
+    },
+    env: project.env ?? {},
+    mcpServers,
+    rules,
+    skills,
+    global: {
+      claudeMd: loadGlobalClaudeMd(),
+      defaultModel: "",
+      defaultEffort: "",
+      env: config.globalEnv ?? {},
+      permissions: readGlobalPermissions(),
+      rules: readGlobalRules(),
+      mcpServers: readGlobalMcpServers() as Record<string, McpServerConfig>,
+      skills: readGlobalSkills(),
+    },
+  };
+
+  return settings;
+}
+
+registerHandler("project-settings", function (clientId: string, message: ClientMessage) {
+  if (message.type === "project-settings:get") {
+    var getMsg = message as ProjectSettingsGetMessage;
+    var result = buildProjectSettings(getMsg.projectSlug);
+    if ("error" in result) {
+      sendTo(clientId, { type: "project-settings:error", projectSlug: getMsg.projectSlug, message: result.error });
+      return;
+    }
+    sendTo(clientId, { type: "project-settings:data", projectSlug: getMsg.projectSlug, settings: result });
+    return;
+  }
+
+  if (message.type === "project-settings:update") {
+    var updateMsg = message as ProjectSettingsUpdateMessage;
+    var projectSlug = updateMsg.projectSlug;
+    var section = updateMsg.section;
+    var settings = updateMsg.settings;
+
+    var project = getProjectBySlug(projectSlug);
+    if (!project) {
+      sendTo(clientId, { type: "project-settings:error", projectSlug, message: "Project not found" });
+      return;
+    }
+    if (!existsSync(project.path)) {
+      sendTo(clientId, { type: "project-settings:error", projectSlug, message: "Project path does not exist on disk" });
+      return;
+    }
+
+    try {
+      if (section === "general") {
+        invalidateConfigCache();
+        var config = loadConfig();
+        var idx = config.projects.findIndex(function (p) { return p.slug === projectSlug; });
+        if (idx !== -1) {
+          if (typeof settings.title === "string") {
+            config.projects[idx].title = settings.title;
+          }
+          if (settings.icon !== undefined) {
+            config.projects[idx].icon = settings.icon as ProjectSettings["icon"];
+          }
+          saveConfig(config);
+        }
+      } else if (section === "claude") {
+        if (typeof settings.claudeMd === "string") {
+          writeProjectClaudeMd(project.path, settings.claudeMd);
+        }
+        var latticeUpdates: Record<string, unknown> = {};
+        if (settings.defaultModel !== undefined) latticeUpdates.defaultModel = settings.defaultModel;
+        if (settings.defaultEffort !== undefined) latticeUpdates.defaultEffort = settings.defaultEffort;
+        if (settings.thinking !== undefined) latticeUpdates.thinking = settings.thinking;
+        if (settings.defaultPermissionMode !== undefined) latticeUpdates.defaultPermissionMode = settings.defaultPermissionMode;
+        if (Object.keys(latticeUpdates).length > 0) {
+          mergeProjectClaudeSettings(project.path, { lattice: latticeUpdates });
+        }
+      } else if (section === "environment") {
+        invalidateConfigCache();
+        var config = loadConfig();
+        var idx = config.projects.findIndex(function (p) { return p.slug === projectSlug; });
+        if (idx !== -1) {
+          config.projects[idx].env = (settings.env as Record<string, string>) ?? {};
+          saveConfig(config);
+        }
+      } else if (section === "mcp") {
+        writeProjectMcpServers(project.path, (settings.mcpServers as Record<string, unknown>) ?? {});
+      } else if (section === "rules") {
+        writeProjectRules(project.path, (settings.rules as Array<{ filename: string; content: string }>) ?? []);
+      } else if (section === "permissions") {
+        mergeProjectClaudeSettings(project.path, {
+          permissions: {
+            allow: (settings.allow as string[]) ?? [],
+            deny: (settings.deny as string[]) ?? [],
+          },
+        });
+      }
+    } catch (err) {
+      var errMsg = err instanceof Error ? err.message : String(err);
+      sendTo(clientId, { type: "project-settings:error", projectSlug, message: errMsg });
+      return;
+    }
+
+    var updated = buildProjectSettings(projectSlug);
+    if ("error" in updated) {
+      sendTo(clientId, { type: "project-settings:error", projectSlug, message: updated.error });
+      return;
+    }
+    sendTo(clientId, { type: "project-settings:data", projectSlug, settings: updated });
+    return;
+  }
+});

package/server/src/handlers/scheduler.ts

@@ -0,0 +1,47 @@
+import type {
+  ClientMessage,
+  SchedulerCreateMessage,
+  SchedulerDeleteMessage,
+  SchedulerToggleMessage,
+} from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { listTasks, createTask, deleteTask, toggleTask } from "../features/scheduler";
+
+registerHandler("scheduler", function (clientId: string, message: ClientMessage) {
+  if (message.type === "scheduler:list") {
+    sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+    return;
+  }
+
+  if (message.type === "scheduler:create") {
+    var createMsg = message as SchedulerCreateMessage;
+    var task = createTask({
+      name: createMsg.name,
+      prompt: createMsg.prompt,
+      cron: createMsg.cron,
+      projectSlug: createMsg.projectSlug,
+    });
+    if (!task) {
+      sendTo(clientId, { type: "chat:error", message: "Invalid cron expression" });
+      return;
+    }
+    sendTo(clientId, { type: "scheduler:task_created", task });
+    sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+    return;
+  }
+
+  if (message.type === "scheduler:delete") {
+    var deleteMsg = message as SchedulerDeleteMessage;
+    deleteTask(deleteMsg.taskId);
+    sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+    return;
+  }
+
+  if (message.type === "scheduler:toggle") {
+    var toggleMsg = message as SchedulerToggleMessage;
+    toggleTask(toggleMsg.taskId);
+    sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+    return;
+  }
+});

package/server/src/handlers/session.ts

@@ -0,0 +1,159 @@
+import type {
+  ClientMessage,
+  SessionActivateMessage,
+  SessionCreateMessage,
+  SessionDeleteMessage,
+  SessionListRequestMessage,
+  SessionRenameMessage,
+} from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { loadConfig } from "../config";
+import {
+  createSession,
+  deleteSession,
+  findProjectSlugForSession,
+  getSessionTitle,
+  getSessionUsage,
+  listSessions,
+  loadSessionHistory,
+  renameSession,
+} from "../project/session";
+import { getContextBreakdown } from "../project/context-breakdown";
+import { setActiveSession } from "./chat";
+import { setActiveProject } from "./fs";
+import { wasSessionInterrupted, clearInterruptedFlag } from "../project/sdk-bridge";
+
+registerHandler("session", function (clientId: string, message: ClientMessage) {
+  if (message.type === "session:list_request") {
+    var listReqMsg = message as SessionListRequestMessage;
+    void listSessions(listReqMsg.projectSlug).then(function (sessions) {
+      sendTo(clientId, {
+        type: "session:list",
+        projectSlug: listReqMsg.projectSlug,
+        sessions,
+      });
+    });
+    return;
+  }
+
+  if (message.type === "session:list_all_request") {
+    var config = loadConfig();
+    var allPromises = config.projects.map(function (p) {
+      return listSessions(p.slug);
+    });
+    void Promise.all(allPromises).then(function (results) {
+      var merged: typeof results[0] = [];
+      for (var i = 0; i < results.length; i++) {
+        for (var j = 0; j < results[i].length; j++) {
+          merged.push(results[i][j]);
+        }
+      }
+      merged.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
+      sendTo(clientId, {
+        type: "session:list_all",
+        sessions: merged.slice(0, 20),
+      });
+    });
+    return;
+  }
+
+  if (message.type === "session:create") {
+    var createMsg = message as SessionCreateMessage;
+    var session = createSession(createMsg.projectSlug);
+    sendTo(clientId, { type: "session:created", session });
+    void listSessions(createMsg.projectSlug).then(function (sessions) {
+      sendTo(clientId, {
+        type: "session:list",
+        projectSlug: createMsg.projectSlug,
+        sessions,
+      });
+    });
+    return;
+  }
+
+  if (message.type === "session:activate") {
+    var activateMsg = message as SessionActivateMessage;
+    setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
+    setActiveProject(clientId, activateMsg.projectSlug);
+    void Promise.all([
+      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId),
+      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId),
+      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId),
+      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId),
+    ]).then(function (results) {
+      var interrupted = wasSessionInterrupted(activateMsg.sessionId);
+      if (interrupted) {
+        clearInterruptedFlag(activateMsg.sessionId);
+      }
+      sendTo(clientId, {
+        type: "session:history",
+        projectSlug: activateMsg.projectSlug,
+        sessionId: activateMsg.sessionId,
+        messages: results[0],
+        title: results[1],
+        interrupted: interrupted || undefined,
+      });
+      var usage = results[2];
+      if (usage) {
+        sendTo(clientId, {
+          type: "chat:context_usage",
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          cacheReadTokens: usage.cacheReadTokens,
+          cacheCreationTokens: usage.cacheCreationTokens,
+          contextWindow: usage.contextWindow,
+        });
+      }
+      var breakdown = results[3];
+      if (breakdown) {
+        sendTo(clientId, {
+          type: "chat:context_breakdown",
+          segments: breakdown.segments,
+          contextWindow: breakdown.contextWindow,
+          autocompactAt: breakdown.autocompactAt,
+        });
+      }
+    });
+    return;
+  }
+
+  if (message.type === "session:rename") {
+    var renameMsg = message as SessionRenameMessage;
+    void findProjectSlugForSession(renameMsg.sessionId).then(function (projectSlug) {
+      if (!projectSlug) {
+        sendTo(clientId, { type: "chat:error", message: "Session not found" });
+        return;
+      }
+      void renameSession(projectSlug, renameMsg.sessionId, renameMsg.title).then(function () {
+        void listSessions(projectSlug).then(function (sessions) {
+          sendTo(clientId, {
+            type: "session:list",
+            projectSlug,
+            sessions,
+          });
+        });
+      });
+    });
+    return;
+  }
+
+  if (message.type === "session:delete") {
+    var deleteMsg = message as SessionDeleteMessage;
+    void findProjectSlugForSession(deleteMsg.sessionId).then(function (deleteProjectSlug) {
+      if (!deleteProjectSlug) {
+        sendTo(clientId, { type: "chat:error", message: "Session not found" });
+        return;
+      }
+      void deleteSession(deleteProjectSlug, deleteMsg.sessionId).then(function () {
+        void listSessions(deleteProjectSlug).then(function (sessions) {
+          sendTo(clientId, {
+            type: "session:list",
+            projectSlug: deleteProjectSlug,
+            sessions,
+          });
+        });
+      });
+    });
+  }
+});

package/server/src/handlers/settings.ts

@@ -0,0 +1,109 @@
+import type { ClientMessage, SettingsGetMessage, SettingsUpdateMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { loadConfig, saveConfig } from "../config";
+import { addProject } from "../project/registry";
+import type { LatticeConfig } from "@lattice/shared";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readGlobalMcpServers, writeGlobalMcpServers, readGlobalSkills } from "../project/project-files";
+import { loadOrCreateIdentity } from "../identity";
+
+function loadGlobalClaudeMd(): string {
+  var mdPath = join(homedir(), ".claude", "CLAUDE.md");
+  if (existsSync(mdPath)) {
+    try {
+      return readFileSync(mdPath, "utf-8");
+    } catch {}
+  }
+  return "";
+}
+
+function saveGlobalClaudeMd(content: string): void {
+  var claudeDir = join(homedir(), ".claude");
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+  writeFileSync(join(claudeDir, "CLAUDE.md"), content, "utf-8");
+}
+
+registerHandler("settings", function (clientId: string, message: ClientMessage) {
+  if (message.type === "settings:get") {
+    var config = loadConfig();
+    var identity = loadOrCreateIdentity();
+    var configWithClaudeMd = { ...config, claudeMd: loadGlobalClaudeMd() };
+    sendTo(clientId, {
+      type: "settings:data",
+      config: configWithClaudeMd,
+      mcpServers: readGlobalMcpServers() as Record<string, import("@lattice/shared").McpServerConfig>,
+      globalSkills: readGlobalSkills(),
+    });
+    sendTo(clientId, {
+      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 };
+      }),
+    });
+    return;
+  }
+
+  if (message.type === "settings:update") {
+    var updateMsg = message as SettingsUpdateMessage;
+    var current = loadConfig();
+
+    var incoming = updateMsg.settings as Record<string, unknown>;
+    if (typeof incoming.claudeMd === "string") {
+      saveGlobalClaudeMd(incoming.claudeMd);
+      delete incoming.claudeMd;
+    }
+
+    if (incoming.mcpServers != null) {
+      writeGlobalMcpServers(incoming.mcpServers as Record<string, unknown>);
+      delete incoming.mcpServers;
+    }
+
+    var incomingProjects = incoming.projects as Array<{ path: string; slug?: string; title: string; env?: Record<string, string> }> | undefined;
+    if (incomingProjects && incomingProjects.length > 0) {
+      for (var i = 0; i < incomingProjects.length; i++) {
+        var proj = incomingProjects[i];
+        addProject(proj.path, proj.title);
+      }
+    }
+
+    var refreshed = loadConfig();
+    var updated: LatticeConfig = {
+      ...refreshed,
+      ...(incoming as Partial<LatticeConfig>),
+      globalEnv: {
+        ...refreshed.globalEnv,
+        ...((incoming.globalEnv as Record<string, string>) ?? {}),
+      },
+      projects: refreshed.projects,
+    };
+    saveConfig(updated);
+    var updatedWithClaudeMd = { ...updated, claudeMd: loadGlobalClaudeMd() };
+    sendTo(clientId, {
+      type: "settings:data",
+      config: updatedWithClaudeMd,
+      mcpServers: readGlobalMcpServers() as Record<string, import("@lattice/shared").McpServerConfig>,
+      globalSkills: readGlobalSkills(),
+    });
+    var updatedIdentity = loadOrCreateIdentity();
+    broadcast({
+      type: "projects:list",
+      projects: updated.projects.map(function (p) {
+        return { slug: p.slug, path: p.path, title: p.title, nodeId: updatedIdentity.id, nodeName: updated.name, isRemote: false };
+      }),
+    });
+    return;
+  }
+
+  if (message.type === "settings:restart") {
+    console.log("[lattice] Restart requested by client");
+    setTimeout(function () {
+      process.exit(0);
+    }, 200);
+    return;
+  }
+});