@cryptiklemur/lattice 1.2.0 → 1.4.0

package/server/src/handlers/fs.ts

@@ -21,7 +21,11 @@ export function clearActiveProject(clientId: string): void {
 registerHandler("fs", function (clientId: string, message: ClientMessage) {
   if (message.type === "fs:list") {
     var listMsg = message as FsListMessage;
-    var projectSlug = activeProjectByClient.get(clientId);
+    var projectSlug = activeProjectByClient.get(clientId) || listMsg.projectSlug;
+    if (listMsg.projectSlug) {
+      setActiveProject(clientId, listMsg.projectSlug);
+      projectSlug = listMsg.projectSlug;
+    }
     if (!projectSlug) {
       sendTo(clientId, { type: "chat:error", message: "No active project for fs:list" });
       return;
@@ -40,7 +44,11 @@ registerHandler("fs", function (clientId: string, message: ClientMessage) {
 
   if (message.type === "fs:read") {
     var readMsg = message as FsReadMessage;
-    var projectSlugRead = activeProjectByClient.get(clientId);
+    var projectSlugRead = activeProjectByClient.get(clientId) || readMsg.projectSlug;
+    if (readMsg.projectSlug) {
+      setActiveProject(clientId, readMsg.projectSlug);
+      projectSlugRead = readMsg.projectSlug;
+    }
     if (!projectSlugRead) {
       sendTo(clientId, { type: "chat:error", message: "No active project for fs:read" });
       return;

package/server/src/handlers/memory.ts

@@ -7,6 +7,9 @@ import { sendTo } from "../ws/broadcast";
 import { loadConfig } from "../config";
 
 function getMemoryDir(projectSlug: string): string | null {
+  if (projectSlug === "__global__") {
+    return join(homedir(), ".claude", "memory");
+  }
   var config = loadConfig();
   var project = config.projects.find(function (p) { return p.slug === projectSlug; });
   if (!project) return null;

package/server/src/handlers/notes.ts

@@ -1,5 +1,6 @@
 import type {
   ClientMessage,
+  NotesListMessage,
   NotesCreateMessage,
   NotesUpdateMessage,
   NotesDeleteMessage,
@@ -10,13 +11,14 @@ import { listNotes, createNote, updateNote, deleteNote } from "../features/stick
 
 registerHandler("notes", function (clientId: string, message: ClientMessage) {
   if (message.type === "notes:list") {
-    sendTo(clientId, { type: "notes:list_result", notes: listNotes() });
+    var listMsg = message as NotesListMessage;
+    sendTo(clientId, { type: "notes:list_result", notes: listNotes(listMsg.projectSlug) });
     return;
   }
 
   if (message.type === "notes:create") {
     var createMsg = message as NotesCreateMessage;
-    var note = createNote(createMsg.content);
+    var note = createNote(createMsg.content, createMsg.projectSlug);
     broadcast({ type: "notes:created", note });
     return;
   }

package/server/src/handlers/scheduler.ts

@@ -3,10 +3,11 @@ import type {
   SchedulerCreateMessage,
   SchedulerDeleteMessage,
   SchedulerToggleMessage,
+  SchedulerUpdateMessage,
 } from "@lattice/shared";
 import { registerHandler } from "../ws/router";
 import { sendTo } from "../ws/broadcast";
-import { listTasks, createTask, deleteTask, toggleTask } from "../features/scheduler";
+import { listTasks, createTask, deleteTask, toggleTask, updateTask } from "../features/scheduler";
 
 registerHandler("scheduler", function (clientId: string, message: ClientMessage) {
   if (message.type === "scheduler:list") {
@@ -44,4 +45,20 @@ registerHandler("scheduler", function (clientId: string, message: ClientMessage)
     sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
     return;
   }
+
+  if (message.type === "scheduler:update") {
+    var updateMsg = message as SchedulerUpdateMessage;
+    var updated = updateTask(updateMsg.taskId, {
+      name: updateMsg.name,
+      prompt: updateMsg.prompt,
+      cron: updateMsg.cron,
+    });
+    if (!updated) {
+      sendTo(clientId, { type: "chat:error", message: "Failed to update task" });
+      return;
+    }
+    sendTo(clientId, { type: "scheduler:task_updated", task: updated });
+    sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+    return;
+  }
 });

package/server/src/handlers/session.ts

@@ -22,7 +22,7 @@ import {
 import { getContextBreakdown } from "../project/context-breakdown";
 import { setActiveSession } from "./chat";
 import { setActiveProject } from "./fs";
-import { wasSessionInterrupted, clearInterruptedFlag } from "../project/sdk-bridge";
+import { wasSessionInterrupted, clearInterruptedFlag, isSessionBusy, watchSessionLock, stopExternalSession } from "../project/sdk-bridge";
 
 registerHandler("session", function (clientId: string, message: ClientMessage) {
   if (message.type === "session:list_request") {
@@ -62,13 +62,6 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     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;
   }
 
@@ -76,6 +69,7 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     var activateMsg = message as SessionActivateMessage;
     setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
     setActiveProject(clientId, activateMsg.projectSlug);
+    watchSessionLock(activateMsg.sessionId);
     void Promise.all([
       loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId),
       getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId),
@@ -86,6 +80,7 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
       if (interrupted) {
         clearInterruptedFlag(activateMsg.sessionId);
       }
+      var busy = isSessionBusy(activateMsg.sessionId);
       sendTo(clientId, {
         type: "session:history",
         projectSlug: activateMsg.projectSlug,
@@ -93,6 +88,7 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
         messages: results[0],
         title: results[1],
         interrupted: interrupted || undefined,
+        busy: busy || undefined,
       });
       var usage = results[2];
       if (usage) {
@@ -156,4 +152,14 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
       });
     });
   }
+
+  if (message.type === "session:stop_external") {
+    var stopMsg = message as { type: string; sessionId: string };
+    var stopped = stopExternalSession(stopMsg.sessionId);
+    if (stopped) {
+      console.log("[lattice] Sent SIGINT to external CLI process for session " + stopMsg.sessionId);
+    } else {
+      sendTo(clientId, { type: "chat:error", message: "No external process found for this session." });
+    }
+  }
 });

package/server/src/handlers/settings.ts

@@ -7,7 +7,21 @@ 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 { readGlobalMcpServers, writeGlobalMcpServers, readGlobalSkills, readGlobalRules } from "../project/project-files";
+
+function detectIdeProjectName(projectPath: string): string | undefined {
+  try {
+    var ideDir = join(projectPath, ".idea");
+    if (!existsSync(ideDir)) return undefined;
+    var ideNameFile = join(ideDir, ".name");
+    if (existsSync(ideNameFile)) {
+      var name = readFileSync(ideNameFile, "utf-8").trim();
+      if (name) return name;
+    }
+    return projectPath.split("/").pop() || undefined;
+  } catch {}
+  return undefined;
+}
 import { loadOrCreateIdentity } from "../identity";
 
 function loadGlobalClaudeMd(): string {
@@ -28,6 +42,21 @@ function saveGlobalClaudeMd(content: string): void {
   writeFileSync(join(claudeDir, "CLAUDE.md"), content, "utf-8");
 }
 
+function loadSpinnerVerbs(): string[] {
+  var claudeSettingsPath = join(homedir(), ".claude", "settings.json");
+  var defaultVerbs = ["Thinking", "Analyzing", "Processing", "Computing", "Evaluating", "Considering", "Examining", "Reviewing"];
+  try {
+    var claudeSettings = JSON.parse(readFileSync(claudeSettingsPath, "utf-8"));
+    if (claudeSettings.spinnerVerbs) {
+      if (claudeSettings.spinnerVerbs.mode === "replace") {
+        return claudeSettings.spinnerVerbs.verbs || [];
+      }
+      return [...defaultVerbs, ...(claudeSettings.spinnerVerbs.verbs || [])];
+    }
+  } catch {}
+  return defaultVerbs;
+}
+
 registerHandler("settings", function (clientId: string, message: ClientMessage) {
   if (message.type === "settings:get") {
     var config = loadConfig();
@@ -38,11 +67,14 @@ registerHandler("settings", function (clientId: string, message: ClientMessage)
       config: configWithClaudeMd,
       mcpServers: readGlobalMcpServers() as Record<string, import("@lattice/shared").McpServerConfig>,
       globalSkills: readGlobalSkills(),
+      globalRules: readGlobalRules(),
+      spinnerVerbs: loadSpinnerVerbs(),
+      wslDistro: process.env.WSL_DISTRO_NAME || undefined,
     });
     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 { slug: p.slug, path: p.path, title: p.title, nodeId: identity.id, nodeName: config.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path) };
       }),
     });
     return;
@@ -93,6 +125,9 @@ registerHandler("settings", function (clientId: string, message: ClientMessage)
       config: updatedWithClaudeMd,
       mcpServers: readGlobalMcpServers() as Record<string, import("@lattice/shared").McpServerConfig>,
       globalSkills: readGlobalSkills(),
+      globalRules: readGlobalRules(),
+      spinnerVerbs: loadSpinnerVerbs(),
+      wslDistro: process.env.WSL_DISTRO_NAME || undefined,
     });
     var updatedIdentity = loadOrCreateIdentity();
     broadcast({

package/server/src/handlers/terminal.ts

@@ -29,14 +29,21 @@ export function cleanupClientTerminals(clientId: string): void {
 
 registerHandler("terminal", function(clientId: string, message: ClientMessage) {
   if (message.type === "terminal:create") {
-    var _msg = message as TerminalCreateMessage;
+    var createMsg = message as TerminalCreateMessage;
     var cwd = homedir();
 
-    var active = getActiveSession(clientId);
-    if (active) {
-      var project = getProjectBySlug(active.projectSlug);
-      if (project) {
-        cwd = project.path;
+    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;
+        }
       }
     }
 

package/server/src/project/pty-worker.cjs

@@ -0,0 +1,83 @@
+// Worker that runs node-pty in a subprocess, communicating via stdin/stdout JSON messages.
+// Running node-pty in a separate process avoids SIGHUP issues with Bun's --watch mode.
+var pty = require("node-pty");
+
+var term = null;
+
+process.stdin.setEncoding("utf-8");
+var buffer = "";
+
+process.stdin.on("data", function (chunk) {
+  buffer += chunk;
+  var lines = buffer.split("\n");
+  buffer = lines.pop();
+  for (var i = 0; i < lines.length; i++) {
+    if (!lines[i].trim()) continue;
+    try {
+      handleMessage(JSON.parse(lines[i]));
+    } catch (e) {
+      // ignore parse errors
+    }
+  }
+});
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + "\n");
+}
+
+function handleMessage(msg) {
+  if (msg.type === "create") {
+    var shell = process.env.SHELL || "bash";
+    term = pty.spawn(shell, [], {
+      name: "xterm-256color",
+      cols: msg.cols || 80,
+      rows: msg.rows || 24,
+      cwd: msg.cwd || process.env.HOME,
+      env: process.env,
+    });
+
+    term.onData(function (data) {
+      send({ type: "data", data: data });
+    });
+
+    term.onExit(function (e) {
+      send({ type: "exit", code: e.exitCode || 0 });
+      process.exit(0);
+    });
+
+    send({ type: "ready", pid: term.pid });
+  }
+
+  if (msg.type === "input" && term) {
+    term.write(msg.data);
+  }
+
+  if (msg.type === "resize" && term) {
+    try {
+      term.resize(msg.cols, msg.rows);
+    } catch (e) {
+      // ignore resize errors
+    }
+  }
+
+  if (msg.type === "kill") {
+    if (term) {
+      try { term.kill(); } catch (e) { /* already dead */ }
+    }
+    process.exit(0);
+  }
+}
+
+process.on("SIGTERM", function () {
+  if (term) {
+    try { term.kill(); } catch (e) { /* already dead */ }
+  }
+  process.exit(0);
+});
+
+process.on("SIGHUP", function () {
+  if (term) {
+    try { term.kill(); } catch (e) { /* already dead */ }
+  }
+  process.exit(0);
+});