@cryptiklemur/lattice 5.12.8 → 5.13.1

package/dist/server/daemon.js

@@ -15,7 +15,7 @@ import { startDiscovery } from "./mesh/discovery.js";
 import { startMeshConnections, onPeerConnected, onPeerDisconnected, onPeerMessage, getAllRemoteProjects } from "./mesh/connector.js";
 import { handleProxyRequest, handleProxyResponse } from "./mesh/proxy.js";
 import { verifyPassphrase, generateSessionToken, addSession, isValidSession } from "./auth/passphrase.js";
-import { log } from "./logger.js";
+import { log, initFileLogger } from "./logger.js";
 import { detectIdeProjectName } from "./handlers/settings.js";
 import "./handlers/session.js";
 import "./handlers/chat.js";
@@ -326,6 +326,7 @@ export async function startDaemon(portOverride, tlsOverride) {
     if (tlsOverride !== null && tlsOverride !== undefined) {
         config.tls = tlsOverride;
     }
+    initFileLogger(getLatticeHome());
     const identity = loadOrCreateIdentity();
     log.server("Node: %s (%s)", config.name, identity.id);
     log.server("Home: %s", getLatticeHome());

package/dist/server/logger.js

@@ -1,21 +1,50 @@
 import createDebug from "debug";
+import { createWriteStream, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { format } from "node:util";
+let fileStream = null;
+export function initFileLogger(latticeHome) {
+    const logsDir = join(latticeHome, "logs");
+    if (!existsSync(logsDir)) {
+        mkdirSync(logsDir, { recursive: true });
+    }
+    const logPath = join(logsDir, "debug.log");
+    fileStream = createWriteStream(logPath, { flags: "a" });
+    fileStream.on("error", function () {
+        fileStream = null;
+    });
+}
+function writeToFile(namespace, fmt, ...args) {
+    if (!fileStream)
+        return;
+    const timestamp = new Date().toISOString();
+    const message = format(fmt, ...args);
+    fileStream.write(timestamp + " " + namespace + " " + message + "\n");
+}
+function createLogger(namespace) {
+    const debugInstance = createDebug(namespace);
+    return function (fmt, ...args) {
+        writeToFile(namespace, fmt, ...args);
+        debugInstance(fmt, ...args);
+    };
+}
 export const log = {
-    server: createDebug("lattice:server"),
-    ws: createDebug("lattice:ws"),
-    chat: createDebug("lattice:chat"),
-    session: createDebug("lattice:session"),
-    mesh: createDebug("lattice:mesh"),
-    meshConnect: createDebug("lattice:mesh:connect"),
-    meshHello: createDebug("lattice:mesh:hello"),
-    meshProxy: createDebug("lattice:mesh:proxy"),
-    router: createDebug("lattice:router"),
-    broadcast: createDebug("lattice:broadcast"),
-    auth: createDebug("lattice:auth"),
-    fs: createDebug("lattice:fs"),
-    analytics: createDebug("lattice:analytics"),
-    plugins: createDebug("lattice:plugins"),
-    update: createDebug("lattice:update"),
-    terminal: createDebug("lattice:terminal"),
-    settings: createDebug("lattice:settings"),
-    superpowers: createDebug("lattice:superpowers"),
+    server: createLogger("lattice:server"),
+    ws: createLogger("lattice:ws"),
+    chat: createLogger("lattice:chat"),
+    session: createLogger("lattice:session"),
+    mesh: createLogger("lattice:mesh"),
+    meshConnect: createLogger("lattice:mesh:connect"),
+    meshHello: createLogger("lattice:mesh:hello"),
+    meshProxy: createLogger("lattice:mesh:proxy"),
+    router: createLogger("lattice:router"),
+    broadcast: createLogger("lattice:broadcast"),
+    auth: createLogger("lattice:auth"),
+    fs: createLogger("lattice:fs"),
+    analytics: createLogger("lattice:analytics"),
+    plugins: createLogger("lattice:plugins"),
+    update: createLogger("lattice:update"),
+    terminal: createLogger("lattice:terminal"),
+    settings: createLogger("lattice:settings"),
+    superpowers: createLogger("lattice:superpowers"),
 };

package/dist/server/project/sdk-bridge.js

@@ -376,9 +376,11 @@ function buildSDKUserMessage(prompt, attachments, sessionId) {
 }
 function pushToExistingStream(session, options) {
     const { text, attachments, clientId, sessionId, model } = options;
+    log.chat("Session %s pushing to existing stream (ended=%s)", sessionId, String(session.ended));
     session.clientId = clientId;
     session.turnStartTime = Date.now();
     session.turnDoneSent = false;
+    session.sawNewTurnContent = false;
     session.activeToolBlocks = {};
     const prompt = resolvePromptText(text);
     const userMsg = buildSDKUserMessage(prompt, attachments, sessionId);
@@ -398,6 +400,7 @@ function pushToExistingStream(session, options) {
 }
 export function startChatStream(options) {
     const { projectSlug, sessionId, text, attachments, clientId, cwd, env, model, effort, isNewSession } = options;
+    log.chat("startChatStream called: session=%s project=%s client=%s", sessionId, projectSlug, clientId);
     const existing = sessionStreams.get(sessionId);
     if (existing && !existing.ended) {
         pushToExistingStream(existing, options);
@@ -470,9 +473,7 @@ export function startChatStream(options) {
         additionalDirectories: savedAdditionalDirs.length > 0 ? savedAdditionalDirs : undefined,
         mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
         stderr: function (data) {
-            if (data.includes("error") || data.includes("Error") || data.includes("credit") || data.includes("Credit") || data.includes("billing") || data.includes("auth")) {
-                log.chat("SDK stderr: %s", data.trim());
-            }
+            log.chat("Session %s SDK stderr: %s", sessionId, data.trim());
         },
     };
     queryOptions.toolConfig = {
@@ -675,6 +676,7 @@ export function startChatStream(options) {
         ended: false,
         accumulatedText: "",
         specId: options.specId,
+        sawNewTurnContent: false,
         analyzer: new ContextAnalyzer(function (msg) {
             const ss = sessionStreams.get(sessionId);
             if (ss)
@@ -685,25 +687,48 @@ export function startChatStream(options) {
     persistStreamState();
     broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
     void (async function () {
+        log.chat("Session %s stream starting (resume=%s, model=%s)", sessionId, String(shouldResume), model || "default");
         try {
             await stream.initializationResult();
+            log.chat("Session %s SDK initialized", sessionId);
         }
         catch (initErr) {
-            log.chat("Session %s SDK initialization warning: %O", sessionId, initErr);
+            log.chat("Session %s SDK initialization FAILED: %O", sessionId, initErr);
+        }
+        if (!shouldResume) {
+            log.chat("Session %s pushing first message to queue", sessionId);
+            mq.push(firstMsg);
         }
-        mq.push(firstMsg);
         try {
+            log.chat("Session %s entering stream loop", sessionId);
+            let msgCount = 0;
+            let replayDone = !shouldResume;
             for await (const msg of stream) {
+                msgCount++;
+                if (msgCount <= 5 || msg.type === "result") {
+                    log.chat("Session %s msg #%d type=%s", sessionId, msgCount, msg.type);
+                }
+                if (!replayDone && msg.type === "result") {
+                    replayDone = true;
+                    log.chat("Session %s replay complete at msg #%d, waiting for connection settle", sessionId, msgCount);
+                    await new Promise(function (resolve) { setTimeout(resolve, 200); });
+                    log.chat("Session %s pushing first message after replay", sessionId);
+                    mq.push(firstMsg);
+                    continue;
+                }
                 processMessage(sessionStream, msg);
             }
+            log.chat("Session %s stream ended normally after %d messages", sessionId, msgCount);
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
+            log.chat("Session %s stream error: %s", sessionId, errMsg);
             if (errMsg.includes("aborted") || errMsg.includes("AbortError")) {
                 log.chat("Session %s stream aborted", sessionId);
             }
             else if (errMsg.includes("Sent before connected")) {
                 log.chat("Session %s SDK WebSocket race condition: %s", sessionId, errMsg);
+                sendTo(sessionStream.clientId, { type: "chat:error", message: "Connection failed. Please try again." });
             }
             else {
                 console.error("[lattice] SDK stream error: " + errMsg);
@@ -811,6 +836,7 @@ function processMessage(ss, msg) {
         const partial = msg;
         const evt = partial.event;
         if (evt.type === "content_block_start") {
+            ss.sawNewTurnContent = true;
             const block = evt.content_block;
             const idx = evt.index;
             if (block.type === "tool_use" && block.id && block.name) {
@@ -941,6 +967,10 @@ function processMessage(ss, msg) {
         return;
     }
     if (msg.type === "result") {
+        if (!ss.sawNewTurnContent) {
+            log.chat("Session %s ignoring replayed result (no new turn content seen)", sessionId);
+            return;
+        }
         const resultMsg = msg;
         const dur = Date.now() - ss.turnStartTime;
         const cost = resultMsg.total_cost_usd || 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "5.12.8",
+  "version": "5.13.1",
   "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>",