@cryptiklemur/lattice 1.3.0 → 1.5.0

package/server/src/project/sdk-bridge.ts

@@ -1,11 +1,13 @@
 import type { Query } from "@anthropic-ai/claude-agent-sdk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import type { SDKMessage, SDKPartialAssistantMessage, SDKResultMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { SDKMessage, SDKPartialAssistantMessage, SDKResultMessage, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { CanUseTool, PermissionMode, PermissionResult, PermissionUpdate } from "@anthropic-ai/claude-agent-sdk";
+import type { MessageParam } from "@anthropic-ai/sdk/resources";
+import type { Attachment } from "@lattice/shared";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { sendTo } from "../ws/broadcast";
+import { sendTo, broadcast } from "../ws/broadcast";
 import { syncSessionToPeers } from "../mesh/session-sync";
 import { resolveSkillContent } from "../handlers/skills";
 import { guessContextWindow } from "./session";
@@ -19,6 +21,7 @@ interface PendingPermission {
   suggestions: PermissionUpdate[] | undefined;
   clientId: string;
   sessionId: string;
+  promptType?: string;
 }
 
 var pendingPermissions = new Map<string, PendingPermission>();
@@ -29,6 +32,7 @@ export interface ChatStreamOptions {
   projectSlug: string;
   sessionId: string;
   text: string;
+  attachments?: Attachment[];
   clientId: string;
   cwd: string;
   env?: Record<string, string>;
@@ -57,6 +61,42 @@ var activeStreams = new Map<string, Query>();
 var streamMetadata = new Map<string, { projectSlug: string; clientId: string; startedAt: number }>();
 var interruptedSessions = new Set<string>();
 
+// Track external lock state so we only broadcast on changes
+var externalLockState = new Map<string, boolean>();
+var watchedSessions = new Set<string>();
+
+/**
+ * Start polling a session's lock file for external CLI usage.
+ * Called when a client activates a session.
+ */
+export function watchSessionLock(sessionId: string): void {
+  watchedSessions.add(sessionId);
+}
+
+/**
+ * Stop polling a session's lock file.
+ */
+export function unwatchSessionLock(sessionId: string): void {
+  watchedSessions.delete(sessionId);
+  externalLockState.delete(sessionId);
+}
+
+// Poll every 3 seconds for external lock changes
+setInterval(function () {
+  for (var sessionId of watchedSessions) {
+    // Skip sessions with active Lattice streams — those are already tracked
+    if (activeStreams.has(sessionId)) continue;
+
+    var locked = isSessionLockedByExternal(sessionId);
+    var prev = externalLockState.get(sessionId) ?? false;
+
+    if (locked !== prev) {
+      externalLockState.set(sessionId, locked);
+      broadcast({ type: "session:busy", sessionId, busy: locked });
+    }
+  }
+}, 3000);
+
 function getStreamStatePath(): string {
   return join(getLatticeHome(), "active-streams.json");
 }
@@ -118,6 +158,98 @@ export function getActiveStream(sessionId: string): Query | undefined {
   return activeStreams.get(sessionId);
 }
 
+/**
+ * Check if a session is controlled by an external process (not Lattice).
+ * Lattice's own active streams are handled by isProcessing on the client,
+ * so this ONLY returns true for external CLI instances.
+ */
+export function isSessionBusy(sessionId: string): boolean {
+  return isSessionLockedByExternal(sessionId);
+}
+
+/**
+ * Check if a PID is the Lattice daemon or one of its child processes.
+ * The SDK spawns child processes (e.g. claude-agent-sdk/cli.js) that hold
+ * lock files — those are NOT external.
+ */
+function isOwnProcess(pid: number): boolean {
+  var myPid = process.pid;
+  if (pid === myPid) return true;
+  // Walk up the process tree to see if pid is a descendant of us
+  var current = pid;
+  for (var i = 0; i < 10; i++) {
+    try {
+      var stat = readFileSync("/proc/" + current + "/stat", "utf-8");
+      // Format: pid (comm) state ppid ...
+      var match = stat.match(/^\d+\s+\([^)]*\)\s+\S+\s+(\d+)/);
+      if (!match) return false;
+      var ppid = parseInt(match[1], 10);
+      if (ppid === myPid) return true;
+      if (ppid <= 1) return false;
+      current = ppid;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+/**
+ * Get PIDs holding the session lock file, excluding Lattice's own process tree.
+ * Returns the list of truly external PIDs.
+ */
+function getExternalLockPids(sessionId: string): number[] {
+  var lockPath = join(homedir(), ".claude", "tasks", sessionId, ".lock");
+  if (!existsSync(lockPath)) return [];
+  try {
+    var result = Bun.spawnSync(["fuser", lockPath], {
+      stderr: "ignore",
+    });
+    if (result.exitCode !== 0) return [];
+    var output = result.stdout.toString().trim();
+    var pids = output.split(/\s+/)
+      .map(function (s) { return parseInt(s, 10); })
+      .filter(function (p) { return !isNaN(p) && !isOwnProcess(p); });
+    return pids;
+  } catch {
+    return [];
+  }
+}
+
+function isSessionLockedByExternal(sessionId: string): boolean {
+  return getExternalLockPids(sessionId).length > 0;
+}
+
+/**
+ * Get the first external PID holding the session lock file.
+ * Used to send SIGINT to stop the external process.
+ */
+function getExternalLockPid(sessionId: string): number | null {
+  var pids = getExternalLockPids(sessionId);
+  return pids.length > 0 ? pids[0] : null;
+}
+
+/**
+ * Gracefully stop an external Claude Code CLI process controlling a session.
+ * Sends SIGINT which triggers Claude Code's graceful shutdown.
+ * Returns true if a signal was sent.
+ */
+export function stopExternalSession(sessionId: string): boolean {
+  var pid = getExternalLockPid(sessionId);
+  if (pid === null) return false;
+  try {
+    process.kill(pid, "SIGINT");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getSessionStreamClientId(sessionId: string): string | undefined {
+  var meta = streamMetadata.get(sessionId);
+  return meta ? meta.clientId : undefined;
+}
+
 export function matchesAllowRules(rules: string[], toolName: string, currentRule: string): boolean {
   for (var i = 0; i < rules.length; i++) {
     var rule = rules[i];
@@ -188,7 +320,7 @@ export function buildPermissionRule(toolName: string, input: Record<string, unkn
 }
 
 export function startChatStream(options: ChatStreamOptions): void {
-  var { projectSlug, sessionId, text, clientId, cwd, env, model, effort, isNewSession } = options;
+  var { projectSlug, sessionId, text, attachments, clientId, cwd, env, model, effort, isNewSession } = options;
   var startTime = Date.now();
 
   if (activeStreams.has(sessionId)) {
@@ -240,16 +372,50 @@ export function startChatStream(options: ChatStreamOptions): void {
   var queryOptions: Parameters<typeof query>[0]["options"] = {
     cwd,
     permissionMode: effectiveMode,
+    promptSuggestions: true,
     additionalDirectories: savedAdditionalDirs.length > 0 ? savedAdditionalDirs : undefined,
     mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers as Record<string, any> : undefined,
   };
 
+  (queryOptions as any).toolConfig = {
+    askUserQuestion: { previewFormat: "html" },
+  };
+
   queryOptions.canUseTool = function (toolName, input, options) {
     var approved = autoApprovedTools.get(sessionId);
     if (approved && approved.has(toolName)) {
       return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID } as PermissionResult);
     }
 
+    if (toolName === "AskUserQuestion") {
+      var promptRequestId = options.toolUseID;
+      var questions = (input as { questions: Array<{ question: string; header: string; options: Array<{ label: string; description: string; preview?: string }>; multiSelect: boolean }> }).questions;
+      sendTo(clientId, {
+        type: "chat:prompt_request",
+        requestId: promptRequestId,
+        questions: questions,
+      });
+      return new Promise<PermissionResult>(function (resolve) {
+        pendingPermissions.set(promptRequestId, {
+          resolve: resolve,
+          toolName: toolName,
+          toolUseID: options.toolUseID,
+          input: input,
+          suggestions: undefined,
+          clientId: clientId,
+          sessionId: sessionId,
+          promptType: "question",
+        });
+      });
+    }
+
+    if (toolName === "ExitPlanMode") {
+      sendTo(clientId, {
+        type: "chat:plan_mode",
+        active: false,
+      });
+    }
+
     if (toolName === "Read") {
       var readPath = (input.file_path || input.path || "") as string;
       if (readPath.startsWith("/tmp/") || readPath === "/tmp") {
@@ -377,10 +543,50 @@ export function startChatStream(options: ChatStreamOptions): void {
   var activeToolBlocks: Record<number, { id: string; name: string; inputJson: string }> = {};
   var doneSent = false;
 
-  var stream = query({ prompt: prompt, options: queryOptions });
+  var queryPrompt: string | AsyncIterable<SDKUserMessage>;
+
+  if (attachments && attachments.length > 0) {
+    var contentBlocks: Array<{ type: "text"; text: string } | { type: "image"; source: { type: "base64"; media_type: string; data: string } }> = [];
+    contentBlocks.push({ type: "text", text: prompt });
+
+    for (var ai = 0; ai < attachments.length; ai++) {
+      var att = attachments[ai];
+      if (att.type === "image" && att.mimeType && !att.mimeType.includes("svg")) {
+        contentBlocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: att.mimeType,
+            data: att.content,
+          },
+        });
+      } else {
+        var prefix = att.name ? "[Attached: " + att.name + "]\n" : "";
+        contentBlocks.push({
+          type: "text",
+          text: prefix + att.content,
+        });
+      }
+    }
+
+    var userMessage: SDKUserMessage = {
+      type: "user",
+      message: { role: "user", content: contentBlocks } as MessageParam,
+      parent_tool_use_id: null,
+    };
+
+    queryPrompt = (async function* () {
+      yield userMessage;
+    })();
+  } else {
+    queryPrompt = prompt;
+  }
+
+  var stream = query({ prompt: queryPrompt, options: queryOptions });
   activeStreams.set(sessionId, stream);
   streamMetadata.set(sessionId, { projectSlug, clientId, startedAt: Date.now() });
   persistStreamState();
+  broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
 
   void (async function () {
     try {
@@ -395,6 +601,7 @@ export function startChatStream(options: ChatStreamOptions): void {
       activeStreams.delete(sessionId);
       streamMetadata.delete(sessionId);
       persistStreamState();
+      broadcast({ type: "session:busy", sessionId, busy: false }, clientId);
 
       var toCleanup: string[] = [];
       pendingPermissions.forEach(function (entry, reqId) {
@@ -421,12 +628,9 @@ export function startChatStream(options: ChatStreamOptions): void {
     if (msg.type === "system") {
       var sysMsg = msg as { type: "system"; subtype?: string; mcp_servers?: { name: string; status: string }[]; tools?: string[] };
       if (sysMsg.subtype === "init") {
-        console.log("[lattice] SDK init - MCP servers:", JSON.stringify(sysMsg.mcp_servers || []));
-        console.log("[lattice] SDK init - tools count:", (sysMsg.tools || []).length);
-        var mcpTools = (sysMsg.tools || []).filter(function (t) { return t.startsWith("mcp__"); });
-        if (mcpTools.length > 0) {
-          console.log("[lattice] SDK init - MCP tools:", mcpTools.join(", "));
-        }
+        var toolCount = (sysMsg.tools || []).length;
+        var mcpCount = (sysMsg.mcp_servers || []).filter(function (s) { return s.status === "connected"; }).length;
+        console.log("[lattice] Session ready: " + toolCount + " tools, " + mcpCount + " MCP servers connected");
       }
       return;
     }
@@ -457,6 +661,23 @@ export function startChatStream(options: ChatStreamOptions): void {
               name: aBlock.name,
               args: JSON.stringify(aBlock.input ?? {}),
             });
+            if (aBlock.name === "TodoWrite" && aBlock.input) {
+              var todoInput = aBlock.input as { todos?: Array<{ id?: string; content: string; status: string; activeForm?: string }> };
+              if (todoInput.todos) {
+                sendTo(clientId, {
+                  type: "chat:todo_update",
+                  todos: todoInput.todos.map(function (t, idx) {
+                    return { id: t.id || String(idx), content: t.content, status: t.status, priority: "medium" };
+                  }),
+                });
+              }
+            }
+            if (aBlock.name === "EnterPlanMode") {
+              sendTo(clientId, { type: "chat:plan_mode", active: true });
+            }
+            if (aBlock.name === "ExitPlanMode") {
+              sendTo(clientId, { type: "chat:plan_mode", active: false });
+            }
           }
         }
       } else if (typeof aContent === "string" && aContent) {
@@ -505,7 +726,29 @@ export function startChatStream(options: ChatStreamOptions): void {
 
       if (evt.type === "content_block_stop") {
         var stopIdx = (evt as { index: number }).index;
-        delete activeToolBlocks[stopIdx];
+        var stoppedBlock = activeToolBlocks[stopIdx];
+        if (stoppedBlock) {
+          if (stoppedBlock.name === "TodoWrite" && stoppedBlock.inputJson) {
+            try {
+              var todoInput = JSON.parse(stoppedBlock.inputJson) as { todos?: Array<{ id?: string; content: string; status: string }> };
+              if (todoInput.todos) {
+                sendTo(clientId, {
+                  type: "chat:todo_update",
+                  todos: todoInput.todos.map(function (t, idx) {
+                    return { id: t.id || String(idx), content: t.content, status: t.status, priority: "medium" };
+                  }),
+                });
+              }
+            } catch {}
+          }
+          if (stoppedBlock.name === "EnterPlanMode") {
+            sendTo(clientId, { type: "chat:plan_mode", active: true });
+          }
+          if (stoppedBlock.name === "ExitPlanMode") {
+            sendTo(clientId, { type: "chat:plan_mode", active: false });
+          }
+          delete activeToolBlocks[stopIdx];
+        }
         return;
       }
 
@@ -533,6 +776,14 @@ export function startChatStream(options: ChatStreamOptions): void {
       return;
     }
 
+    if (msg.type === "prompt_suggestion") {
+      var suggestion = (msg as { type: string; suggestion: string }).suggestion;
+      if (suggestion) {
+        sendTo(clientId, { type: "chat:prompt_suggestion", suggestion: suggestion });
+      }
+      return;
+    }
+
     if (msg.type === "result") {
       var resultMsg = msg as SDKResultMessage;
       var dur = Date.now() - startTime;
@@ -558,7 +809,11 @@ export function startChatStream(options: ChatStreamOptions): void {
       }
 
       doneSent = true;
+      activeStreams.delete(sessionId);
+      streamMetadata.delete(sessionId);
+      persistStreamState();
       sendTo(clientId, { type: "chat:done", cost: cost, duration: dur });
+      broadcast({ type: "session:busy", sessionId, busy: false }, clientId);
       syncSessionToPeers(cwd, projectSlug, sessionId);
       return;
     }

package/server/src/project/session.ts

@@ -18,7 +18,7 @@ function getProjectPath(projectSlug: string): string | null {
   return project ? project.path : null;
 }
 
-function projectPathToHash(projectPath: string): string {
+export function projectPathToHash(projectPath: string): string {
   return projectPath.replace(/\//g, "-");
 }
 
@@ -43,7 +43,7 @@ var FALLBACK_PRICING: Record<string, { input: number; output: number }> = {
   "claude-haiku-4-5": { input: 0.80, output: 4 },
 };
 
-function loadPricing(): void {
+export function loadPricing(): void {
   if (pricingLoaded) return;
   pricingLoaded = true;
   fetch(LITELLM_PRICING_URL).then(function (res) {
@@ -69,7 +69,7 @@ function loadPricing(): void {
 
 loadPricing();
 
-function getPricing(model: string): { input: number; output: number; cacheRead?: number; cacheCreation?: number } {
+export function getPricing(model: string): { input: number; output: number; cacheRead?: number; cacheCreation?: number } {
   if (pricingCache[model]) return pricingCache[model];
   for (var key in pricingCache) {
     if (key.includes(model) || model.includes(key)) return pricingCache[key];
@@ -84,7 +84,7 @@ function getPricing(model: string): { input: number; output: number; cacheRead?:
   return FALLBACK_PRICING["claude-sonnet-4-6"];
 }
 
-function estimateCost(model: string, inputTokens: number, outputTokens: number, cacheRead: number, cacheCreation: number): number {
+export function estimateCost(model: string, inputTokens: number, outputTokens: number, cacheRead: number, cacheCreation: number): number {
   var pricing = getPricing(model);
   var normalInput = inputTokens - cacheRead - cacheCreation;
   var inputCost = (normalInput * pricing.input) / 1000000;

package/server/src/project/terminal.ts

@@ -1,15 +1,33 @@
 import { randomUUID } from "node:crypto";
-import type { IPty } from "node-pty";
+import { spawn } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+import { join } from "node:path";
 
-var terminals = new Map<string, IPty>();
-var pty: typeof import("node-pty") | null = null;
+interface TerminalWorker {
+  process: ChildProcess;
+  send: (msg: object) => void;
+}
+
+var terminals = new Map<string, TerminalWorker>();
 
-function getPty(): typeof import("node-pty") {
-  if (!pty) {
-    pty = require("node-pty") as typeof import("node-pty");
+// node-pty doesn't work under Bun (child gets SIGHUP immediately).
+// We run it in a Node.js subprocess instead, communicating via JSON over stdio.
+var WORKER_PATH = join(import.meta.dir, "pty-worker.cjs");
+
+// node-pty lives in Bun's module cache — resolve the path so Node can find it.
+var NODE_MODULES_PATH = (function () {
+  // Bun can resolve the module — use it to find the actual path
+  try {
+    var resolved = require.resolve("node-pty");
+    // resolved = .../node_modules/.bun/node-pty@X.Y.Z/node_modules/node-pty/lib/index.js
+    // We need: .../node_modules/.bun/node-pty@X.Y.Z/node_modules
+    var parts = resolved.split("/node_modules/");
+    parts.pop(); // remove node-pty/lib/index.js
+    return parts.join("/node_modules/") + "/node_modules";
+  } catch {
+    return join(import.meta.dir, "..", "..", "..", "node_modules");
   }
-  return pty;
-}
+})();
 
 export function createTerminal(
   cwd: string,
@@ -17,53 +35,79 @@ export function createTerminal(
   onExit: (code: number) => void,
 ): string {
   var termId = randomUUID();
-  var shell = process.env.SHELL || "bash";
-  var lib = getPty();
 
-  var term = lib.spawn(shell, [], {
-    name: "xterm-256color",
-    cols: 80,
-    rows: 24,
+  var child = spawn("node", [WORKER_PATH], {
+    stdio: ["pipe", "pipe", "ignore"],
     cwd: cwd,
-    env: process.env as Record<string, string>,
+    env: { ...process.env, NODE_PATH: NODE_MODULES_PATH },
   });
 
-  term.onData(onData);
-  term.onExit(function(e) {
-    terminals.delete(termId);
-    onExit(e.exitCode ?? 0);
+  var buffer = "";
+
+  child.stdout!.setEncoding("utf-8");
+  child.stdout!.on("data", function (chunk: string) {
+    buffer += chunk;
+    var lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (var i = 0; i < lines.length; i++) {
+      if (!lines[i].trim()) continue;
+      try {
+        var msg = JSON.parse(lines[i]);
+        if (msg.type === "data") {
+          onData(msg.data);
+        } else if (msg.type === "exit") {
+          terminals.delete(termId);
+          onExit(msg.code ?? 0);
+        }
+      } catch {
+        // ignore parse errors
+      }
+    }
+  });
+
+  child.on("exit", function () {
+    if (terminals.has(termId)) {
+      terminals.delete(termId);
+      onExit(0);
+    }
   });
 
-  terminals.set(termId, term);
+  function sendMsg(msg: object) {
+    if (child.stdin && !child.stdin.destroyed) {
+      child.stdin.write(JSON.stringify(msg) + "\n");
+    }
+  }
+
+  terminals.set(termId, { process: child, send: sendMsg });
+
+  // Tell the worker to create the PTY
+  sendMsg({ type: "create", cwd: cwd, cols: 80, rows: 24 });
+
   return termId;
 }
 
 export function writeToTerminal(termId: string, data: string): void {
-  var term = terminals.get(termId);
-  if (term) {
-    term.write(data);
+  var worker = terminals.get(termId);
+  if (worker) {
+    worker.send({ type: "input", data: data });
   }
 }
 
 export function resizeTerminal(termId: string, cols: number, rows: number): void {
-  var term = terminals.get(termId);
-  if (term) {
-    term.resize(cols, rows);
+  var worker = terminals.get(termId);
+  if (worker) {
+    worker.send({ type: "resize", cols: cols, rows: rows });
   }
 }
 
 export function destroyTerminal(termId: string): void {
-  var term = terminals.get(termId);
-  if (term) {
-    try {
-      term.kill();
-    } catch {
-      // already dead
-    }
+  var worker = terminals.get(termId);
+  if (worker) {
+    worker.send({ type: "kill" });
     terminals.delete(termId);
   }
 }
 
-export function getTerminal(termId: string): IPty | undefined {
+export function getTerminal(termId: string): TerminalWorker | undefined {
   return terminals.get(termId);
 }

package/shared/src/analytics.ts

@@ -0,0 +1,24 @@
+export interface AnalyticsPayload {
+  totalCost: number;
+  totalSessions: number;
+  totalTokens: { input: number; output: number; cacheRead: number; cacheCreation: number };
+  cacheHitRate: number;
+  avgSessionCost: number;
+  avgSessionDuration: number;
+
+  costOverTime: Array<{ date: string; total: number; opus: number; sonnet: number; haiku: number; other: number }>;
+  cumulativeCost: Array<{ date: string; total: number }>;
+  sessionsOverTime: Array<{ date: string; count: number }>;
+  tokensOverTime: Array<{ date: string; input: number; output: number; cacheRead: number }>;
+  cacheHitRateOverTime: Array<{ date: string; rate: number }>;
+
+  costDistribution: Array<{ bucket: string; count: number }>;
+  sessionBubbles: Array<{ id: string; title: string; cost: number; tokens: number; timestamp: number; project: string }>;
+
+  modelUsage: Array<{ model: string; sessions: number; cost: number; tokens: number; percentage: number }>;
+  projectBreakdown: Array<{ project: string; cost: number; sessions: number; tokens: number }>;
+  toolUsage: Array<{ tool: string; count: number; avgCost: number }>;
+}
+
+export type AnalyticsPeriod = "24h" | "7d" | "30d" | "90d" | "all";
+export type AnalyticsScope = "global" | "project" | "session";

package/shared/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./analytics.js";
 export * from "./constants.js";
 export * from "./messages.js";
 export * from "./models.js";