@cryptiklemur/lattice 1.3.0 → 1.4.0

package/client/src/styles/global.css

@@ -101,6 +101,13 @@ html, body {
   font-family: var(--font-mono);
   font-size: 13px;
   line-height: 1.6;
+  overflow-x: auto;
+  max-width: 100%;
+}
+
+.prose {
+  overflow-wrap: break-word;
+  word-break: break-word;
 }
 
 .prose code {
@@ -116,6 +123,79 @@ html, body {
   background: transparent;
 }
 
+.prose .table-wrapper {
+  overflow-x: auto;
+  margin: 0.75em 0;
+  border-radius: 0.5rem;
+  border: 1px solid oklch(from var(--color-base-content) l c h / 0.08);
+  background: oklch(from var(--color-base-100) l c h / 0.6);
+  scrollbar-width: thin;
+}
+
+.prose table {
+  border-collapse: collapse;
+  width: 100%;
+  font-size: 12px;
+  font-family: var(--font-mono);
+  margin: 0;
+  border: none;
+  line-height: 1.5;
+}
+
+.prose thead {
+  background: oklch(from var(--color-base-content) l c h / 0.04);
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+
+.prose th {
+  text-align: left;
+  font-weight: 600;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  padding: 8px 14px;
+  color: oklch(from var(--color-base-content) l c h / 0.35);
+  border-bottom: 1px solid oklch(from var(--color-base-content) l c h / 0.1);
+  white-space: nowrap;
+  user-select: none;
+}
+
+.prose td {
+  padding: 8px 14px;
+  color: oklch(from var(--color-base-content) l c h / 0.65);
+  border-bottom: 1px solid oklch(from var(--color-base-content) l c h / 0.04);
+  vertical-align: top;
+  white-space: normal;
+  min-width: 60px;
+}
+
+.prose td code {
+  font-size: 11px;
+  white-space: nowrap;
+  padding: 1px 5px;
+  border-radius: 3px;
+  background: oklch(from var(--color-primary) l c h / 0.08);
+  color: oklch(from var(--color-primary) l c h / 0.8);
+}
+
+.prose tbody tr:last-child td {
+  border-bottom: none;
+}
+
+.prose tbody tr {
+  transition: background-color 150ms ease;
+}
+
+.prose tbody tr:nth-child(even) {
+  background: oklch(from var(--color-base-content) l c h / 0.015);
+}
+
+.prose tbody tr:hover {
+  background: oklch(from var(--color-primary) l c h / 0.04);
+}
+
 .bg-lattice-grid {
   background-color: transparent;
 }
@@ -156,6 +236,40 @@ html, body {
   }
 }
 
+/* Override DaisyUI drawer for smooth slide transitions on mobile.
+   DaisyUI defaults use opacity on the whole drawer-side which causes
+   an instant vanish. We keep drawer-side always opacity:1 and instead
+   slide the content panel + fade the overlay independently. */
+@media (max-width: 1023px) {
+  /* Keep the container itself always fully opaque so the slide is visible.
+     Use visibility + pointer-events to control interactivity. */
+  .drawer-side {
+    opacity: 1 !important;
+    transition: visibility 0s linear 0.25s !important;
+  }
+
+  .drawer-toggle:checked ~ .drawer-side {
+    transition: visibility 0s linear 0s !important;
+  }
+
+  /* Sidebar content: slide in/out using translate (matches DaisyUI's property) */
+  .drawer-side > *:not(.drawer-overlay) {
+    will-change: translate;
+    transition: translate 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+  }
+
+  /* Overlay: fade in/out */
+  .drawer-side > .drawer-overlay {
+    will-change: opacity;
+    opacity: 0;
+    transition: opacity 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+  }
+
+  .drawer-toggle:checked ~ .drawer-side > .drawer-overlay {
+    opacity: 1;
+  }
+}
+
 .scrollbar-hidden {
   scrollbar-width: none;
   -ms-overflow-style: none;
@@ -165,6 +279,15 @@ html, body {
   display: none;
 }
 
+@keyframes waveform {
+  0%, 100% { height: 4px; opacity: 0.3; }
+  50% { height: 16px; opacity: 0.8; }
+}
+
+.animate-waveform {
+  animation: waveform 0.6s ease-in-out infinite;
+}
+
 @media (prefers-reduced-motion: reduce) {
   *, *::before, *::after {
     animation-duration: 0.01ms !important;

package/client/src/utils/editorUrl.ts

@@ -0,0 +1,62 @@
+var JETBRAINS_IDS: Record<string, string> = {
+  webstorm: "webstorm",
+  intellij: "idea",
+  pycharm: "pycharm",
+  goland: "goland",
+};
+
+function toWindowsPath(linuxPath: string, wslDistro: string): string {
+  return "\\\\" + "wsl.localhost\\" + wslDistro + linuxPath.replace(/\//g, "\\");
+}
+
+function buildJetBrainsUrl(ideId: string, filePath: string, line?: number, projectName?: string): string {
+  var url = "jetbrains://" + ideId + "/navigate/reference?";
+  if (projectName) {
+    url += "project=" + encodeURIComponent(projectName);
+  }
+  if (filePath) {
+    url += (projectName ? "&" : "") + "path=" + encodeURIComponent(filePath);
+    if (line) {
+      url += "&line=" + line;
+    }
+  }
+  return url;
+}
+
+export interface EditorUrlOptions {
+  editorType: string;
+  projectPath: string;
+  filePath: string;
+  line?: number;
+  wslDistro?: string;
+  ideProjectName?: string;
+}
+
+export function getEditorUrl(editorType: string, projectPath: string, filePath: string, line?: number, wslDistro?: string, ideProjectName?: string): string | null {
+  var fullPath = filePath === "." ? projectPath : projectPath + "/" + filePath;
+  var resolvedPath = wslDistro ? toWindowsPath(fullPath, wslDistro) : fullPath;
+
+  var jetbrainsId = JETBRAINS_IDS[editorType];
+  if (jetbrainsId) {
+    if (ideProjectName) {
+      var jbPath = filePath === "." ? "" : filePath;
+      return buildJetBrainsUrl(jetbrainsId, jbPath, line, ideProjectName);
+    }
+    return buildJetBrainsUrl(jetbrainsId, resolvedPath, line);
+  }
+
+  if (editorType === "vscode" || editorType === "vscode-insiders" || editorType === "cursor") {
+    var scheme = editorType;
+    var isFile = filePath !== ".";
+    var lineSuffix = isFile ? ":" + (line || 1) : "";
+    if (wslDistro) {
+      return scheme + "://vscode-remote/wsl+" + wslDistro + fullPath + lineSuffix;
+    }
+    return scheme + "://file/" + resolvedPath + lineSuffix;
+  }
+  if (editorType === "sublime") {
+    return "subl://open?url=file://" + encodeURIComponent(resolvedPath) + (line ? "&line=" + line : "");
+  }
+
+  return null;
+}

package/client/vite.config.ts

@@ -1,9 +1,52 @@
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 import tailwindcss from "@tailwindcss/vite";
+import { VitePWA } from "vite-plugin-pwa";
 
 export default defineConfig({
-  plugins: [tailwindcss(), react()],
+  plugins: [
+    tailwindcss(),
+    react(),
+    VitePWA({
+      registerType: "prompt",
+      workbox: {
+        globPatterns: ["**/*.{js,css,html,svg,png,woff2}"],
+        navigateFallback: "/index.html",
+        navigateFallbackDenylist: [/^\/ws/, /^\/api/],
+        runtimeCaching: [
+          {
+            urlPattern: /^https?:\/\/.*\.(?:js|css|woff2)$/,
+            handler: "CacheFirst",
+            options: {
+              cacheName: "static-assets",
+              expiration: { maxEntries: 100, maxAgeSeconds: 30 * 24 * 60 * 60 },
+            },
+          },
+          {
+            urlPattern: /^https?:\/\/.*\.(?:svg|png|jpg|jpeg|gif|webp)$/,
+            handler: "CacheFirst",
+            options: {
+              cacheName: "images",
+              expiration: { maxEntries: 50, maxAgeSeconds: 30 * 24 * 60 * 60 },
+            },
+          },
+        ],
+      },
+      manifest: {
+        name: "Lattice",
+        short_name: "Lattice",
+        description: "Multi-machine agentic dashboard for Claude Code",
+        display: "standalone",
+        start_url: "/",
+        theme_color: "#0d0d0d",
+        background_color: "#0d0d0d",
+        icons: [
+          { src: "/icons/icon-192.svg", sizes: "192x192", type: "image/svg+xml", purpose: "maskable" },
+          { src: "/icons/icon-512.svg", sizes: "512x512", type: "image/svg+xml", purpose: "maskable" },
+        ],
+      },
+    }),
+  ],
   server: {
     host: "0.0.0.0",
     open: true,
@@ -11,9 +54,18 @@ export default defineConfig({
       "/ws": {
         target: "ws://localhost:7654",
         ws: true,
+        configure: function (proxy) {
+          proxy.on("error", function () {});
+          proxy.on("proxyReqWs", function (_proxyReq, _req, socket) {
+            socket.on("error", function () {});
+          });
+        },
       },
       "/api": {
         target: "http://localhost:7654",
+        configure: function (proxy) {
+          proxy.on("error", function () {});
+        },
       },
     },
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",

package/server/src/daemon.ts

@@ -14,7 +14,9 @@ import { ensureCerts } from "./tls";
 import type { ClientMessage, MeshMessage } from "@lattice/shared";
 import "./handlers/session";
 import "./handlers/chat";
-import { loadInterruptedSessions } from "./project/sdk-bridge";
+import "./handlers/attachment";
+import { loadInterruptedSessions, unwatchSessionLock } from "./project/sdk-bridge";
+import { clearActiveSession, getActiveSession } from "./handlers/chat";
 import "./handlers/fs";
 import "./handlers/terminal";
 import "./handlers/settings";
@@ -25,9 +27,11 @@ import "./handlers/scheduler";
 import "./handlers/notes";
 import "./handlers/skills";
 import "./handlers/memory";
+import "./handlers/editor";
 import { startScheduler } from "./features/scheduler";
 import { loadNotes } from "./features/sticky-notes";
 import { cleanupClientTerminals } from "./handlers/terminal";
+import { cleanupClient as cleanupClientAttachments } from "./handlers/attachment";
 
 interface WsData {
   id: string;
@@ -299,8 +303,14 @@ export async function startDaemon(portOverride?: number | null): Promise<void> {
         }
       },
       close(ws: ServerWebSocket<WsData>) {
+        var activeSession = getActiveSession(ws.data.id);
+        if (activeSession) {
+          unwatchSessionLock(activeSession.sessionId);
+        }
+        clearActiveSession(ws.data.id);
         removeClient(ws.data.id);
         cleanupClientTerminals(ws.data.id);
+        cleanupClientAttachments(ws.data.id);
         console.log(`[lattice] Client disconnected: ${ws.data.id}`);
       },
     },

package/server/src/features/scheduler.ts

@@ -245,6 +245,29 @@ export function createTask(data: {
   return task;
 }
 
+export function updateTask(taskId: string, data: { name?: string; prompt?: string; cron?: string }): ScheduledTask | null {
+  var task: ScheduledTask | null = null;
+  for (var i = 0; i < tasks.length; i++) {
+    if (tasks[i].id === taskId) {
+      task = tasks[i];
+      break;
+    }
+  }
+  if (!task) return null;
+
+  if (data.cron && data.cron !== task.cron) {
+    var parsed = parseCron(data.cron);
+    if (!parsed) return null;
+    task.cron = data.cron;
+    task.nextRunAt = task.enabled ? nextRunTime(data.cron) : null;
+  }
+  if (data.name !== undefined) task.name = data.name;
+  if (data.prompt !== undefined) task.prompt = data.prompt;
+  task.updatedAt = Date.now();
+  saveSchedules();
+  return task;
+}
+
 export function deleteTask(taskId: string): boolean {
   var idx = -1;
   for (var i = 0; i < tasks.length; i++) {

package/server/src/features/sticky-notes.ts

@@ -61,17 +61,19 @@ function saveNotes(): void {
   }
 }
 
-export function listNotes(): StickyNote[] {
-  return notes.slice();
+export function listNotes(projectSlug?: string): StickyNote[] {
+  if (!projectSlug) return notes.slice();
+  return notes.filter(function (n) { return n.projectSlug === projectSlug; });
 }
 
-export function createNote(content: string): StickyNote {
+export function createNote(content: string, projectSlug?: string): StickyNote {
   var now = Date.now();
   var note: StickyNote = {
     id: "note_" + now + "_" + randomBytes(3).toString("hex"),
     content,
     createdAt: now,
     updatedAt: now,
+    projectSlug,
   };
   notes.push(note);
   saveNotes();

package/server/src/handlers/attachment.ts

@@ -0,0 +1,172 @@
+import type { Attachment } from "@lattice/shared";
+import type { AttachmentChunkMessage, AttachmentCompleteMessage, ClientMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+
+interface PendingUpload {
+  chunks: Map<number, Buffer>;
+  totalChunks: number;
+  receivedCount: number;
+  createdAt: number;
+}
+
+var stores = new Map<string, Map<string, PendingUpload>>();
+var completed = new Map<string, Map<string, Attachment>>();
+
+var TTL_MS = 5 * 60 * 1000;
+var CLEANUP_INTERVAL_MS = 60 * 1000;
+
+function getClientStore(clientId: string): Map<string, PendingUpload> {
+  var store = stores.get(clientId);
+  if (!store) {
+    store = new Map();
+    stores.set(clientId, store);
+  }
+  return store;
+}
+
+function getClientCompleted(clientId: string): Map<string, Attachment> {
+  var store = completed.get(clientId);
+  if (!store) {
+    store = new Map();
+    completed.set(clientId, store);
+  }
+  return store;
+}
+
+registerHandler("attachment", function (clientId: string, message: ClientMessage) {
+  if (message.type === "attachment:chunk") {
+    var msg = message as AttachmentChunkMessage;
+    var store = getClientStore(clientId);
+
+    var pending = store.get(msg.attachmentId);
+    if (!pending) {
+      pending = {
+        chunks: new Map(),
+        totalChunks: msg.totalChunks,
+        receivedCount: 0,
+        createdAt: Date.now(),
+      };
+      store.set(msg.attachmentId, pending);
+    }
+
+    if (pending.chunks.has(msg.chunkIndex)) {
+      sendTo(clientId, {
+        type: "attachment:error",
+        attachmentId: msg.attachmentId,
+        error: "Duplicate chunk index: " + msg.chunkIndex,
+      });
+      return;
+    }
+
+    pending.chunks.set(msg.chunkIndex, Buffer.from(msg.data, "base64"));
+    pending.receivedCount++;
+
+    sendTo(clientId, {
+      type: "attachment:progress",
+      attachmentId: msg.attachmentId,
+      received: pending.receivedCount,
+      total: pending.totalChunks,
+    });
+    return;
+  }
+
+  if (message.type === "attachment:complete") {
+    var msg = message as AttachmentCompleteMessage;
+    var store = getClientStore(clientId);
+    var pending = store.get(msg.attachmentId);
+
+    if (!pending) {
+      sendTo(clientId, {
+        type: "attachment:error",
+        attachmentId: msg.attachmentId,
+        error: "No chunks received for this attachment",
+      });
+      return;
+    }
+
+    if (pending.receivedCount !== pending.totalChunks) {
+      sendTo(clientId, {
+        type: "attachment:error",
+        attachmentId: msg.attachmentId,
+        error: "Missing chunks: received " + pending.receivedCount + " of " + pending.totalChunks,
+      });
+      return;
+    }
+
+    var buffers: Buffer[] = [];
+    for (var i = 0; i < pending.totalChunks; i++) {
+      var chunk = pending.chunks.get(i);
+      if (!chunk) {
+        sendTo(clientId, {
+          type: "attachment:error",
+          attachmentId: msg.attachmentId,
+          error: "Missing chunk at index " + i,
+        });
+        return;
+      }
+      buffers.push(chunk);
+    }
+
+    var assembled = Buffer.concat(buffers);
+    var isText = msg.attachmentType === "paste" || isTextMimeType(msg.mimeType);
+    var content = isText ? assembled.toString("utf-8") : assembled.toString("base64");
+
+    var attachment: Attachment = {
+      type: msg.attachmentType,
+      name: msg.name,
+      content,
+      mimeType: msg.mimeType,
+      size: msg.size,
+      lineCount: msg.lineCount,
+    };
+
+    var completedStore = getClientCompleted(clientId);
+    completedStore.set(msg.attachmentId, attachment);
+    store.delete(msg.attachmentId);
+    return;
+  }
+});
+
+function isTextMimeType(mime: string): boolean {
+  if (mime.startsWith("text/")) return true;
+  var textTypes = [
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+    "application/x-yaml",
+    "application/yaml",
+    "image/svg+xml",
+  ];
+  return textTypes.indexOf(mime) !== -1;
+}
+
+export function getAttachments(clientId: string, ids: string[]): Attachment[] {
+  var store = getClientCompleted(clientId);
+  var result: Attachment[] = [];
+  for (var i = 0; i < ids.length; i++) {
+    var att = store.get(ids[i]);
+    if (att) {
+      result.push(att);
+      store.delete(ids[i]);
+    }
+  }
+  return result;
+}
+
+export function cleanupClient(clientId: string): void {
+  stores.delete(clientId);
+  completed.delete(clientId);
+}
+
+setInterval(function () {
+  var now = Date.now();
+  stores.forEach(function (store) {
+    store.forEach(function (pending, id) {
+      if (now - pending.createdAt > TTL_MS) {
+        store.delete(id);
+      }
+    });
+  });
+}, CLEANUP_INTERVAL_MS);

package/server/src/handlers/chat.ts

@@ -1,9 +1,10 @@
-import type { ChatSendMessage, ChatPermissionResponseMessage, ChatSetPermissionModeMessage, ClientMessage } from "@lattice/shared";
+import type { ChatSendMessage, ChatPermissionResponseMessage, ChatSetPermissionModeMessage, ChatPromptResponseMessage, ClientMessage } from "@lattice/shared";
 import { registerHandler } from "../ws/router";
 import { sendTo } from "../ws/broadcast";
 import { getProjectBySlug } from "../project/registry";
 import { loadConfig } from "../config";
 import { startChatStream, getPendingPermission, deletePendingPermission, addAutoApprovedTool, setSessionPermissionOverride, getActiveStream, buildPermissionRule } from "../project/sdk-bridge";
+import { getAttachments } from "./attachment";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -122,10 +123,15 @@ registerHandler("chat", function (clientId: string, message: ClientMessage) {
     var config = loadConfig();
     var env = Object.assign({}, config.globalEnv, project.env);
 
+    var attachments = sendMsg.attachmentIds
+      ? getAttachments(clientId, sendMsg.attachmentIds)
+      : [];
+
     startChatStream({
       projectSlug: active.projectSlug,
       sessionId: active.sessionId,
       text: sendMsg.text,
+      attachments,
       clientId,
       cwd: project.path,
       env: Object.keys(env).length > 0 ? env : undefined,
@@ -137,7 +143,17 @@ registerHandler("chat", function (clientId: string, message: ClientMessage) {
   }
 
   if (message.type === "chat:cancel") {
-    sendTo(clientId, { type: "chat:error", message: "Cancel not yet implemented." });
+    var active = activeSessionByClient.get(clientId);
+    if (!active) {
+      sendTo(clientId, { type: "chat:error", message: "No active session." });
+      return;
+    }
+    var stream = getActiveStream(active.sessionId);
+    if (!stream) {
+      sendTo(clientId, { type: "chat:error", message: "No active stream to cancel." });
+      return;
+    }
+    stream.interrupt().catch(function () {});
     return;
   }
 
@@ -176,6 +192,31 @@ registerHandler("chat", function (clientId: string, message: ClientMessage) {
     return;
   }
 
+  if (message.type === "chat:prompt_response") {
+    var promptRespMsg = message as ChatPromptResponseMessage;
+    var pendingPrompt = getPendingPermission(promptRespMsg.requestId);
+    if (!pendingPrompt || pendingPrompt.promptType !== "question") {
+      return;
+    }
+
+    var updatedInput = Object.assign({}, pendingPrompt.input, {
+      answers: promptRespMsg.answers,
+    });
+    if (promptRespMsg.annotations) {
+      (updatedInput as Record<string, unknown>).annotations = promptRespMsg.annotations;
+    }
+
+    pendingPrompt.resolve({
+      behavior: "allow",
+      updatedInput: updatedInput,
+      toolUseID: pendingPrompt.toolUseID,
+    });
+
+    sendTo(clientId, { type: "chat:prompt_resolved", requestId: promptRespMsg.requestId });
+    deletePendingPermission(promptRespMsg.requestId);
+    return;
+  }
+
   if (message.type === "chat:set_permission_mode") {
     var modeMsg = message as ChatSetPermissionModeMessage;
     var activeSession = activeSessionByClient.get(clientId);

package/server/src/handlers/editor.ts

@@ -0,0 +1,40 @@
+import { execSync } from "node:child_process";
+import type { ClientMessage, EditorDetectMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+
+var binaryNames: Record<string, string[]> = {
+  "vscode": ["code"],
+  "vscode-insiders": ["code-insiders"],
+  "cursor": ["cursor"],
+  "webstorm": ["webstorm", "webstorm.sh", "wstorm"],
+  "intellij": ["idea", "idea.sh"],
+  "pycharm": ["pycharm", "pycharm.sh", "charm"],
+  "goland": ["goland", "goland.sh"],
+  "notepad++": ["notepad++"],
+  "sublime": ["subl", "sublime_text"],
+};
+
+function detectEditorPath(editorType: string): string | null {
+  var names = binaryNames[editorType];
+  if (!names) return null;
+
+  for (var i = 0; i < names.length; i++) {
+    try {
+      var result = execSync("which " + names[i], { encoding: "utf-8", timeout: 3000 }).trim();
+      if (result) return result;
+    } catch {
+      // not found
+    }
+  }
+  return null;
+}
+
+registerHandler("editor", function (clientId: string, message: ClientMessage) {
+  if (message.type === "editor:detect") {
+    var detectMsg = message as EditorDetectMessage;
+    var detectedPath = detectEditorPath(detectMsg.editorType);
+    sendTo(clientId, { type: "editor:detect_result", editorType: detectMsg.editorType, path: detectedPath });
+    return;
+  }
+});