@cryptiklemur/lattice 5.12.8 → 5.13.0

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,6 +376,7 @@ 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;
@@ -398,6 +399,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 +472,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 = {
@@ -685,20 +685,31 @@ 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);
         }
+        log.chat("Session %s pushing first message to queue", sessionId);
         mq.push(firstMsg);
         try {
+            log.chat("Session %s entering stream loop", sessionId);
+            let msgCount = 0;
             for await (const msg of stream) {
+                msgCount++;
+                if (msgCount <= 3 || msg.type === "result") {
+                    log.chat("Session %s msg #%d type=%s", sessionId, msgCount, msg.type);
+                }
                 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);
             }

package/package.json

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