@cryptiklemur/lattice 1.14.2 → 1.16.0

package/server/src/project/session.ts

@@ -11,10 +11,11 @@ import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import type { HistoryMessage, SessionPreview, SessionSummary } from "@lattice/shared";
 import { loadConfig } from "../config";
+import { log } from "../logger";
 
 function getProjectPath(projectSlug: string): string | null {
   var config = loadConfig();
-  var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+  var project = config.projects.find(function (p: typeof config.projects[number]) { return p.slug === projectSlug; });
   return project ? project.path : null;
 }
 
@@ -417,7 +418,7 @@ export async function listSessions(projectSlug: string): Promise<SessionSummary[
     summaries.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
     return summaries;
   } catch (err) {
-    console.warn("[lattice] Failed to list SDK sessions:", err);
+    log.session("Failed to list SDK sessions: %O", err);
     return [];
   }
 }
@@ -442,7 +443,7 @@ export async function loadSessionHistory(projectSlug: string, sessionId: string)
     var messages = await getSessionMessages(sessionId, options);
     return convertSessionMessages(messages);
   } catch (err) {
-    console.warn("[lattice] Failed to load session history:", err);
+    log.session("Failed to load session history: %O", err);
     return [];
   }
 }
@@ -467,7 +468,7 @@ export async function renameSession(projectSlug: string, sessionId: string, titl
     await sdkRenameSession(sessionId, title, options);
     return true;
   } catch (err) {
-    console.warn("[lattice] Failed to rename session:", err);
+    log.session("Failed to rename session: %O", err);
     return false;
   }
 }
@@ -489,7 +490,7 @@ export async function deleteSession(projectSlug: string, sessionId: string): Pro
     unlinkSync(sessionFile);
     return true;
   } catch (err) {
-    console.warn("[lattice] Failed to delete session:", err);
+    log.session("Failed to delete session: %O", err);
     return false;
   }
 }

package/server/src/ws/router.ts

@@ -1,5 +1,6 @@
 import type { ClientMessage } from "@lattice/shared";
 import { sendTo } from "./broadcast";
+import { log } from "../logger";
 
 var _registry: typeof import("../project/registry") | null = null;
 var _connector: typeof import("../mesh/connector") | null = null;
@@ -81,18 +82,18 @@ export function routeMessage(clientId: string, message: ClientMessage): void {
       if (result && typeof result.then === "function") {
         result.then(undefined, function (err: unknown) {
           var stack = err instanceof Error ? err.stack : String(err);
-          console.error("[lattice] Async handler error for " + message.type + ":", stack);
+          log.ws("Async handler error for %s: %s", message.type, stack);
           sendTo(clientId, { type: "chat:error", message: "Internal server error processing " + message.type });
         });
       }
     } catch (err) {
       var stack = err instanceof Error ? (err as Error).stack : String(err);
-      console.error("[lattice] Handler error for " + message.type + ":", stack);
+      log.ws("Handler error for %s: %s", message.type, stack);
       sendTo(clientId, { type: "chat:error", message: "Internal server error processing " + message.type });
     }
     return;
   }
-  console.warn(`[lattice] No handler for message type: ${message.type}`);
+  log.ws("No handler for message type: %s", message.type);
   sendTo(clientId, { type: "error", message: `Unknown message type: ${message.type}` });
 }
 
@@ -112,7 +113,7 @@ function proxyMessage(clientId: string, nodeId: string, projectSlug: string, mes
   try {
     getProxy().proxyToRemoteNode(nodeId, projectSlug, clientId, message);
   } catch (err) {
-    console.error("[router] Failed to proxy message:", err);
+    log.ws("Failed to proxy message: %O", err);
     sendTo(clientId, { type: "chat:error", message: "Failed to proxy message to remote node" });
   }
 }

package/server/tsconfig.json

@@ -10,6 +10,10 @@
   "include": [
     "src"
   ],
+  "exclude": [
+    "dist",
+    "node_modules"
+  ],
   "references": [
     { "path": "../shared" }
   ]

package/shared/src/messages.ts

@@ -5,6 +5,7 @@ import type {
   LatticeConfig,
   LoopStatus,
   MarketplaceSkill,
+  MessageBookmark,
   NodeInfo,
   ProjectInfo,
   ScheduledTask,
@@ -394,6 +395,10 @@ export interface SessionStopExternalMessage {
   sessionId: string;
 }
 
+export interface BudgetOverrideMessage {
+  type: "budget:override";
+}
+
 export interface AnalyticsRequestMessage {
   type: "analytics:request";
   requestId: string;
@@ -418,6 +423,26 @@ export interface AnalyticsErrorMessage {
   message: string;
 }
 
+export interface BookmarkListMessage {
+  type: "bookmark:list";
+  projectSlug?: string;
+  sessionId?: string;
+}
+
+export interface BookmarkAddMessage {
+  type: "bookmark:add";
+  sessionId: string;
+  projectSlug: string;
+  messageUuid: string;
+  messageText: string;
+  messageType: "user" | "assistant";
+}
+
+export interface BookmarkRemoveMessage {
+  type: "bookmark:remove";
+  id: string;
+}
+
 export type ClientMessage =
   | SessionCreateMessage
   | SessionActivateMessage
@@ -475,7 +500,11 @@ export type ClientMessage =
   | EditorDetectMessage
   | ChatPromptResponseMessage
   | AnalyticsRequestMessage
-  | SessionPreviewRequestMessage;
+  | SessionPreviewRequestMessage
+  | BookmarkListMessage
+  | BookmarkAddMessage
+  | BookmarkRemoveMessage
+  | BudgetOverrideMessage;
 
 export interface SessionListMessage {
   type: "session:list";
@@ -812,6 +841,12 @@ export interface BrowseSuggestionsResultMessage {
   }>;
 }
 
+export interface BookmarkListResultMessage {
+  type: "bookmark:list_result";
+  scope: "session" | "all";
+  bookmarks: MessageBookmark[];
+}
+
 export type ServerMessage =
   | SessionListMessage
   | SessionCreatedMessage
@@ -875,7 +910,23 @@ export type ServerMessage =
   | ChatPlanModeMessage
   | AnalyticsDataMessage
   | AnalyticsErrorMessage
-  | SessionPreviewMessage;
+  | SessionPreviewMessage
+  | BookmarkListResultMessage
+  | BudgetStatusMessage
+  | BudgetExceededMessage;
+
+export interface BudgetStatusMessage {
+  type: "budget:status";
+  dailySpend: number;
+  dailyLimit: number;
+  enforcement: "warning" | "soft-block" | "hard-block";
+}
+
+export interface BudgetExceededMessage {
+  type: "budget:exceeded";
+  dailySpend: number;
+  dailyLimit: number;
+}
 
 export interface MeshHelloMessage {
   type: "mesh:hello";

package/shared/src/models.ts

@@ -58,8 +58,10 @@ export interface Attachment {
   lineCount?: number;
 }
 
+export type HistoryMessageType = "user" | "assistant" | "tool_start" | "tool_result" | "permission_request" | "prompt_question" | "todo_update";
+
 export interface HistoryMessage {
-  type: string;
+  type: HistoryMessageType;
   uuid?: string;
   text?: string;
   toolId?: string;
@@ -121,6 +123,10 @@ export interface LatticeConfig {
   };
   setupComplete?: boolean;
   wsl?: boolean | "auto";
+  costBudget?: {
+    dailyLimit: number;
+    enforcement: "warning" | "soft-block" | "hard-block";
+  };
 }
 
 export interface StickyNote {
@@ -158,6 +164,16 @@ export interface MarketplaceSkill {
   installs: number;
 }
 
+export interface MessageBookmark {
+  id: string;
+  sessionId: string;
+  projectSlug: string;
+  messageUuid: string;
+  messageText: string;
+  messageType: "user" | "assistant";
+  createdAt: number;
+}
+
 export interface LoopStatus {
   id: string;
   projectSlug: string;

package/shared/src/project-settings.ts

@@ -1,6 +1,5 @@
 export type ProjectIcon =
   | { type: "lucide"; name: string }
-  | { type: "emoji"; value: string }
   | { type: "text"; value: string; color?: string }
   | { type: "image"; path: string };
 

package/shared/tsconfig.json

@@ -7,5 +7,9 @@
   "include": [
     "src"
   ],
+  "exclude": [
+    "dist",
+    "node_modules"
+  ],
   "references": []
 }

package/tests/accessibility.spec.ts

@@ -0,0 +1,77 @@
+import { test, expect } from "@playwright/test";
+
+test.beforeEach(async function ({ page }) {
+  await page.evaluate(function () {
+    if ("serviceWorker" in navigator) {
+      navigator.serviceWorker.getRegistrations().then(function (registrations) {
+        registrations.forEach(function (r) { r.unregister(); });
+      });
+    }
+    caches.keys().then(function (names) {
+      names.forEach(function (name) { caches.delete(name); });
+    });
+  });
+});
+
+test.describe("Focus and modal behavior", function () {
+  test("Add Project modal traps focus", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var addButton = page.locator("button[title='Add project']");
+    await expect(addButton).toBeVisible({ timeout: 5000 });
+    await addButton.click();
+    await page.waitForTimeout(500);
+
+    var modal = page.locator("[role='dialog'][aria-label='Add Project']");
+    await expect(modal).toBeVisible({ timeout: 5000 });
+
+    var pathInput = modal.locator("#project-path");
+    await expect(pathInput).toBeFocused();
+
+    var focusableElements = modal.locator(
+      "input, button, [tabindex]:not([tabindex='-1'])"
+    );
+    var focusableCount = await focusableElements.count();
+
+    for (var i = 0; i < focusableCount + 2; i++) {
+      await page.keyboard.press("Tab");
+      await page.waitForTimeout(50);
+    }
+
+    var activeElement = page.locator(":focus");
+    var activeInModal = await modal.locator(":focus").count();
+    expect(activeInModal).toBeGreaterThan(0);
+  });
+
+  test("Escape closes the Add Project modal", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var addButton = page.locator("button[title='Add project']");
+    await addButton.click();
+    await page.waitForTimeout(500);
+
+    var modal = page.locator("[role='dialog'][aria-label='Add Project']");
+    await expect(modal).toBeVisible({ timeout: 5000 });
+
+    await page.keyboard.press("Escape");
+    await page.waitForTimeout(300);
+
+    await expect(modal).not.toBeVisible();
+  });
+
+  test("connection status dot is present on the Lattice logo", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var dashboardButton = page.locator("[title='Lattice Dashboard']");
+    await expect(dashboardButton).toBeVisible();
+
+    var statusDot = dashboardButton.locator("div.rounded-full.border-\\[1\\.5px\\]");
+    await expect(statusDot).toBeVisible();
+
+    var dotClasses = await statusDot.getAttribute("class");
+    expect(dotClasses).toMatch(/bg-success|bg-warning|bg-error/);
+  });
+});

package/tests/keyboard-shortcuts.spec.ts

@@ -0,0 +1,74 @@
+import { test, expect } from "@playwright/test";
+
+test.beforeEach(async function ({ page }) {
+  await page.evaluate(function () {
+    if ("serviceWorker" in navigator) {
+      navigator.serviceWorker.getRegistrations().then(function (registrations) {
+        registrations.forEach(function (r) { r.unregister(); });
+      });
+    }
+    caches.keys().then(function (names) {
+      names.forEach(function (name) { caches.delete(name); });
+    });
+  });
+});
+
+test.describe("Keyboard interactions", function () {
+  test("pressing ? opens the shortcuts overlay", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    await page.keyboard.press("?");
+    await page.waitForTimeout(300);
+
+    var shortcutsHeading = page.locator("text='Keyboard Shortcuts'");
+    await expect(shortcutsHeading).toBeVisible({ timeout: 5000 });
+  });
+
+  test("pressing Escape closes the shortcuts overlay", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    await page.keyboard.press("?");
+    await page.waitForTimeout(300);
+
+    var shortcutsHeading = page.locator("text='Keyboard Shortcuts'");
+    await expect(shortcutsHeading).toBeVisible({ timeout: 5000 });
+
+    await page.keyboard.press("Escape");
+    await page.waitForTimeout(300);
+
+    await expect(shortcutsHeading).not.toBeVisible();
+  });
+
+  test("Ctrl+K opens the command palette", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    await page.keyboard.press("Control+k");
+    await page.waitForTimeout(300);
+
+    var paletteInput = page.locator("input[placeholder*='Search']").or(
+      page.locator("[role='dialog'] input[type='text']")
+    );
+    await expect(paletteInput.first()).toBeVisible({ timeout: 5000 });
+  });
+
+  test("Escape closes the command palette", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    await page.keyboard.press("Control+k");
+    await page.waitForTimeout(300);
+
+    var paletteInput = page.locator("input[placeholder*='Search']").or(
+      page.locator("[role='dialog'] input[type='text']")
+    );
+    await expect(paletteInput.first()).toBeVisible({ timeout: 5000 });
+
+    await page.keyboard.press("Escape");
+    await page.waitForTimeout(300);
+
+    await expect(paletteInput.first()).not.toBeVisible();
+  });
+});

package/tests/message-actions.spec.ts

@@ -0,0 +1,112 @@
+import { test, expect } from "@playwright/test";
+
+test.beforeEach(async function ({ page }) {
+  await page.evaluate(function () {
+    if ("serviceWorker" in navigator) {
+      navigator.serviceWorker.getRegistrations().then(function (registrations) {
+        registrations.forEach(function (r) { r.unregister(); });
+      });
+    }
+    caches.keys().then(function (names) {
+      names.forEach(function (name) { caches.delete(name); });
+    });
+  });
+});
+
+test.describe("Chat message hover actions", function () {
+  test.beforeEach(async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var projectButtons = page.locator("button:has(svg[aria-hidden='true'])").filter({
+      has: page.locator("text=/^[A-Z]{2,3}$/"),
+    });
+
+    var count = await projectButtons.count();
+    if (count === 0) {
+      test.skip(true, "No projects available to test");
+      return;
+    }
+
+    await projectButtons.first().click();
+    await page.waitForTimeout(1500);
+
+    var sessionButtons = page.locator("button[aria-label^='Session:']");
+    var sessionCount = await sessionButtons.count();
+
+    if (sessionCount === 0) {
+      test.skip(true, "No sessions available to test");
+      return;
+    }
+
+    await sessionButtons.first().click();
+    await page.waitForTimeout(2000);
+  });
+
+  test("hovering a message reveals Copy and New Session buttons", async function ({ page }) {
+    var messages = page.locator(".group\\/msg");
+    var messageCount = await messages.count();
+
+    if (messageCount === 0) {
+      test.skip(true, "No messages available to test");
+      return;
+    }
+
+    var targetMessage = messages.first();
+    await targetMessage.hover();
+    await page.waitForTimeout(300);
+
+    var copyButton = targetMessage.locator("button[title*='Copy']");
+    await expect(copyButton).toBeVisible({ timeout: 5000 });
+
+    var newSessionButton = targetMessage.locator("button[title='Start new session with this message']");
+    var hasNewSession = await newSessionButton.count();
+    if (hasNewSession > 0) {
+      await expect(newSessionButton).toBeVisible();
+    }
+  });
+
+  test("clicking New Session creates a session with prefilled input", async function ({ page }) {
+    var userMessages = page.locator(".chat.chat-end .group\\/msg, .chat-end.group\\/msg");
+    var userMessageCount = await userMessages.count();
+
+    if (userMessageCount === 0) {
+      var allMessages = page.locator(".group\\/msg");
+      var allCount = await allMessages.count();
+      if (allCount === 0) {
+        test.skip(true, "No messages available to test");
+        return;
+      }
+
+      await allMessages.first().hover();
+      await page.waitForTimeout(300);
+
+      var newSessionBtn = allMessages.first().locator("button[title='Start new session with this message']");
+      if (await newSessionBtn.count() === 0) {
+        test.skip(true, "No messages with New Session action available");
+        return;
+      }
+
+      await newSessionBtn.click();
+    } else {
+      await userMessages.first().hover();
+      await page.waitForTimeout(300);
+
+      var newSessionBtn2 = userMessages.first().locator("button[title='Start new session with this message']");
+      if (await newSessionBtn2.count() === 0) {
+        test.skip(true, "New Session button not found on user message");
+        return;
+      }
+
+      await newSessionBtn2.click();
+    }
+
+    await page.waitForTimeout(2000);
+
+    var textarea = page.locator("textarea");
+    if (await textarea.count() > 0) {
+      var value = await textarea.inputValue();
+      expect(value.length).toBeGreaterThan(0);
+    }
+  });
+});

package/tests/onboarding.spec.ts

@@ -0,0 +1,72 @@
+import { test, expect } from "@playwright/test";
+
+test.beforeEach(async function ({ page }) {
+  await page.evaluate(function () {
+    if ("serviceWorker" in navigator) {
+      navigator.serviceWorker.getRegistrations().then(function (registrations) {
+        registrations.forEach(function (r) { r.unregister(); });
+      });
+    }
+    caches.keys().then(function (names) {
+      names.forEach(function (name) { caches.delete(name); });
+    });
+  });
+});
+
+test.describe("Onboarding - new user flow", function () {
+  test("dashboard loads with project cards", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var dashboardButton = page.locator("[title='Lattice Dashboard']");
+    await expect(dashboardButton).toBeVisible();
+  });
+
+  test("clicking a project shows sessions list in sidebar", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var projectButtons = page.locator("button:has(svg[aria-hidden='true'])").filter({
+      has: page.locator("text=/^[A-Z]{2,3}$/"),
+    });
+
+    var count = await projectButtons.count();
+    if (count === 0) {
+      test.skip(true, "No projects available to test");
+      return;
+    }
+
+    await projectButtons.first().click();
+    await page.waitForTimeout(1500);
+
+    var sessionLabels = page.locator("text=/Today|Yesterday|This Week|This Month|Older|No sessions yet/");
+    await expect(sessionLabels.first()).toBeVisible({ timeout: 10000 });
+  });
+
+  test("project dashboard shows stats", async function ({ page }) {
+    await page.goto("/");
+    await page.waitForSelector("[title='Lattice Dashboard']", { timeout: 10000 });
+
+    var projectButtons = page.locator("button:has(svg[aria-hidden='true'])").filter({
+      has: page.locator("text=/^[A-Z]{2,3}$/"),
+    });
+
+    var count = await projectButtons.count();
+    if (count === 0) {
+      test.skip(true, "No projects available to test");
+      return;
+    }
+
+    await projectButtons.first().click();
+    await page.waitForTimeout(1000);
+
+    var dashboardLink = page.locator("button", { hasText: "Dashboard" });
+    if (await dashboardLink.isVisible()) {
+      await dashboardLink.click();
+      await page.waitForTimeout(1000);
+    }
+
+    var sidebar = page.locator("text=/Sessions|MCP Servers|Dashboard/").first();
+    await expect(sidebar).toBeVisible({ timeout: 10000 });
+  });
+});