@cryptiklemur/lattice 1.46.7 → 2.0.0

package/{server/src → src/server}/handlers/plugins.ts

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import type {
   ClientMessage,
   PluginInfo,
@@ -550,17 +550,16 @@ registerHandler("plugin", function (clientId: string, message: ClientMessage) {
     var installMsg = message as { type: "plugin:install"; name: string; marketplace: string };
     var installArg = installMsg.name + "@" + installMsg.marketplace;
     try {
-      var proc = Bun.spawn(["claude", "plugin", "install", installArg], {
+      var proc = spawn("claude", ["plugin", "install", installArg], {
         cwd: homedir(),
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: ["ignore", "pipe", "pipe"],
       });
 
       var timeout = setTimeout(function () {
         proc.kill();
       }, 120000);
 
-      void proc.exited.then(function (code) {
+      proc.on("close", function (code) {
         clearTimeout(timeout);
         if (code === 0) {
           sendTo(clientId, { type: "plugin:install_result", success: true, message: "Installed " + installMsg.name + " successfully" });
@@ -579,17 +578,16 @@ registerHandler("plugin", function (clientId: string, message: ClientMessage) {
     var uninstallMsg = message as { type: "plugin:uninstall"; name: string; marketplace: string };
     var uninstallArg = uninstallMsg.name + "@" + uninstallMsg.marketplace;
     try {
-      var uninstallProc = Bun.spawn(["claude", "plugin", "uninstall", uninstallArg], {
+      var uninstallProc = spawn("claude", ["plugin", "uninstall", uninstallArg], {
         cwd: homedir(),
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: ["ignore", "pipe", "pipe"],
       });
 
       var uninstallTimeout = setTimeout(function () {
         uninstallProc.kill();
       }, 60000);
 
-      void uninstallProc.exited.then(function (code) {
+      uninstallProc.on("close", function (code) {
         clearTimeout(uninstallTimeout);
         if (code === 0) {
           sendTo(clientId, { type: "plugin:uninstall_result", success: true, message: "Uninstalled " + uninstallMsg.name + " successfully" });
@@ -608,17 +606,16 @@ registerHandler("plugin", function (clientId: string, message: ClientMessage) {
     var updateMsg = message as { type: "plugin:update"; name: string; marketplace: string };
     var updateArg = updateMsg.name + "@" + updateMsg.marketplace;
     try {
-      var updateProc = Bun.spawn(["claude", "plugin", "update", updateArg], {
+      var updateProc = spawn("claude", ["plugin", "update", updateArg], {
         cwd: homedir(),
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: ["ignore", "pipe", "pipe"],
       });
 
       var updateTimeout = setTimeout(function () {
         updateProc.kill();
       }, 120000);
 
-      void updateProc.exited.then(function (code) {
+      updateProc.on("close", function (code) {
         clearTimeout(updateTimeout);
         if (code === 0) {
           sendTo(clientId, { type: "plugin:update_result", success: true, message: "Updated " + updateMsg.name + " successfully" });

package/{server/src → src/server}/handlers/session.ts

@@ -20,14 +20,16 @@ import {
   getSessionUsage,
   listSessions,
   invalidateSessionCache,
+  invalidateHistoryCache,
   getSessionHistoryPage,
   loadSessionHistory,
   renameSession,
+  getSessionFileSizeBytes,
 } from "../project/session";
 import { getContextBreakdown } from "../project/context-breakdown";
 import { setActiveSession, getActiveSession } from "./chat";
 import { setActiveProject } from "./fs";
-import { wasSessionInterrupted, clearInterruptedFlag, isSessionBusy, watchSessionLock, stopExternalSession, getBusyOwner } from "../project/sdk-bridge";
+import { wasSessionInterrupted, clearInterruptedFlag } from "../project/sdk-bridge";
 import { log } from "../logger";
 
 registerHandler("session", function (clientId: string, message: ClientMessage) {
@@ -102,10 +104,12 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
   }
 
   if (message.type === "session:activate") {
-    var activateMsg = message as SessionActivateMessage;
+    var activateMsg = message as SessionActivateMessage & { refresh?: boolean };
     setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
     setActiveProject(clientId, activateMsg.projectSlug);
-    watchSessionLock(activateMsg.sessionId);
+    invalidateHistoryCache(activateMsg.sessionId);
+    var fileSize = getSessionFileSizeBytes(activateMsg.projectSlug, activateMsg.sessionId);
+    sendTo(clientId, { type: "session:loading_progress", sessionId: activateMsg.sessionId, fileSize });
     var activateT0 = Date.now();
     void loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).then(function (historyResult) {
       log.session("session:activate history: %dms", Date.now() - activateT0);
@@ -114,8 +118,6 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
       if (interrupted) {
         clearInterruptedFlag(activateMsg.sessionId);
       }
-      var busy = isSessionBusy(activateMsg.sessionId);
-      var busyOwner = busy ? getBusyOwner(activateMsg.sessionId) : undefined;
       sendTo(clientId, {
         type: "session:history",
         projectSlug: activateMsg.projectSlug,
@@ -123,8 +125,6 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
         messages: historyResult.messages,
         title: title,
         interrupted: interrupted || undefined,
-        busy: busy || undefined,
-        busyOwner: busyOwner,
         totalMessages: historyResult.totalMessages,
         hasMore: historyResult.hasMore,
       });
@@ -222,13 +222,4 @@ 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) {
-      log.session("Sent SIGINT to external CLI process for session %s", stopMsg.sessionId);
-    } else {
-      sendTo(clientId, { type: "chat:error", message: "No external process found for this session." });
-    }
-  }
 });

package/{server/src → src/server}/handlers/settings.ts

@@ -122,6 +122,9 @@ registerHandler("settings", function (clientId: string, message: ClientMessage)
       },
       projects: refreshed.projects,
     };
+    if ("costBudget" in incoming && incoming.costBudget == null) {
+      delete (updated as unknown as Record<string, unknown>).costBudget;
+    }
     saveConfig(updated);
     var updatedWithClaudeMd = { ...updated, claudeMd: loadGlobalClaudeMd() };
     sendTo(clientId, {

package/{server/src → src/server}/handlers/skills.ts

@@ -1,7 +1,7 @@
 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 { execSync, spawn } from "node:child_process";
 import type { ClientMessage } from "@lattice/shared";
 import type { SkillInfo } from "@lattice/shared";
 import { registerHandler } from "../ws/router";
@@ -270,17 +270,16 @@ registerHandler("skills", function (clientId: string, message: ClientMessage) {
     }
 
     try {
-      var proc = Bun.spawn(["npx", "skillsadd", installMsg.source], {
+      var proc = spawn("npx", ["skillsadd", installMsg.source], {
         cwd: cwd,
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: ["ignore", "pipe", "pipe"],
       });
 
       var timeout = setTimeout(function () {
         proc.kill();
       }, 60000);
 
-      void proc.exited.then(function (code) {
+      proc.on("close", function (code) {
         clearTimeout(timeout);
         skillsCache = null;
         if (code === 0) {
@@ -346,17 +345,16 @@ registerHandler("skills", function (clientId: string, message: ClientMessage) {
   if (message.type === "skills:update") {
     var updateMsg = message as { type: "skills:update"; source: string };
     try {
-      var updateProc = Bun.spawn(["npx", "skillsadd", updateMsg.source], {
+      var updateProc = spawn("npx", ["skillsadd", updateMsg.source], {
         cwd: homedir(),
-        stdout: "pipe",
-        stderr: "pipe",
+        stdio: ["ignore", "pipe", "pipe"],
       });
 
       var updateTimeout = setTimeout(function () {
         updateProc.kill();
       }, 60000);
 
-      void updateProc.exited.then(function (code) {
+      updateProc.on("close", function (code) {
         clearTimeout(updateTimeout);
         skillsCache = null;
         if (code === 0) {

package/src/server/handlers/themes.ts

@@ -0,0 +1,121 @@
+import { join } from "node:path";
+import { readdir, readFile, writeFile, unlink, mkdir } from "node:fs/promises";
+import type {
+  ClientMessage,
+  ThemeSaveMessage,
+  ThemeDeleteMessage,
+} from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo, broadcast } from "../ws/broadcast";
+import { getLatticeHome } from "../config";
+
+function themesDir(): string {
+  return join(getLatticeHome(), "themes");
+}
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+async function ensureThemesDir(): Promise<void> {
+  await mkdir(themesDir(), { recursive: true });
+}
+
+async function loadAllThemes(): Promise<Array<{ name: string; author: string; variant: string; filename: string; colors: Record<string, string> }>> {
+  await ensureThemesDir();
+  var dir = themesDir();
+  var files = await readdir(dir);
+  var jsonFiles = files.filter((f) => f.endsWith(".json"));
+  var themes: Array<{ name: string; author: string; variant: string; filename: string; colors: Record<string, string> }> = [];
+
+  for (var file of jsonFiles) {
+    try {
+      var raw = await readFile(join(dir, file), "utf-8");
+      var data = JSON.parse(raw);
+      var colors: Record<string, string> = {};
+      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: string, message: ClientMessage) {
+  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 as ThemeSaveMessage;
+    var slug = slugify(saveMsg.name);
+    var filename = slug + ".json";
+    var themeData: Record<string, string> = {
+      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: Record<string, string> = {};
+    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 as ThemeDeleteMessage;
+    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/{server/src → src/server}/handlers/update.ts

@@ -1,12 +1,11 @@
 import { chmodSync, writeFileSync, accessSync, copyFileSync, unlinkSync, constants as fsConstants } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import type { ClientMessage } from "@lattice/shared";
 import { registerHandler } from "../ws/router";
 import { sendTo, broadcast } from "../ws/broadcast";
 import { checkForUpdate, getPackageName, getGitHubRepo, getInstallMode } from "../update-checker";
-import { IS_COMPILED } from "../runtime";
 
 function getAssetName(): string {
   var platform = process.platform === "darwin" ? "darwin" : "linux";
@@ -96,35 +95,18 @@ registerHandler("update", function (clientId: string, message: ClientMessage) {
   }
 
   if (message.type === "update:apply") {
-    if (IS_COMPILED) {
-      void downloadBinaryUpdate().then(function (result) {
-        sendTo(clientId, { type: "update:apply_result", success: result.success, message: result.message });
-        if (result.success) {
-          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 {
+    {
       var pkgName = getPackageName();
       try {
-        var proc = Bun.spawn(["bun", "install", "-g", pkgName + "@latest"], {
-          stdout: "pipe",
-          stderr: "pipe",
+        var proc = spawn("npm", ["install", "-g", pkgName + "@latest"], {
+          stdio: ["ignore", "pipe", "pipe"],
         });
 
         var timeout = setTimeout(function () {
           proc.kill();
         }, 120000);
 
-        void proc.exited.then(function (code) {
+        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." });