clay-server 2.26.0 → 2.27.0-beta.1

package/lib/project-user-message.js

@@ -0,0 +1,631 @@
+var path = require("path");
+var fs = require("fs");
+
+/**
+ * Attach user-message handler and remaining small handlers
+ * (sticky notes, terminals, context sources, browser extension,
+ *  scheduled tasks gate, loop delegation, schedule_message,
+ *  and the main "message" dispatch) to a project context.
+ *
+ * ctx fields:
+ *   cwd, slug, isMate, osUsers,
+ *   sm, sdk, nm, tm,
+ *   send, sendTo, sendToSession, sendToSessionOthers,
+ *   clients, opts,
+ *   usersModule, matesModule,
+ *   getSessionForWs, getLinuxUserForSession, getOsUserInfoForWs,
+ *   hydrateImageRefs, saveImageFile, imagesDir,
+ *   onProcessingChanged, onSessionDone,
+ *   _loop              - { handleLoopMessage: fn(ws, msg) }
+ *   browserState       - { _browserTabList, _extensionWs, pendingExtensionRequests } (mutable refs)
+ *   sendExtensionCommandAny, requestTabContext,
+ *   startFileWatch, stopFileWatch,
+ *   scheduleMessage, cancelScheduledMessage,
+ *   loadContextSources, saveContextSources,
+ *   digestDmTurn, gateMemory,
+ *   getSDK             - lazy ESM loader returning Promise<sdk>
+ */
+function attachUserMessage(ctx) {
+  var cwd = ctx.cwd;
+  var slug = ctx.slug;
+  var isMate = ctx.isMate;
+  var osUsers = ctx.osUsers;
+
+  var sm = ctx.sm;
+  var sdk = ctx.sdk;
+  var nm = ctx.nm;
+  var tm = ctx.tm;
+
+  var send = ctx.send;
+  var sendTo = ctx.sendTo;
+  var sendToSession = ctx.sendToSession;
+  var sendToSessionOthers = ctx.sendToSessionOthers;
+
+  var clients = ctx.clients;
+  var opts = ctx.opts;
+
+  var usersModule = ctx.usersModule;
+  var matesModule = ctx.matesModule;
+
+  var getSessionForWs = ctx.getSessionForWs;
+  var getLinuxUserForSession = ctx.getLinuxUserForSession;
+  var getOsUserInfoForWs = ctx.getOsUserInfoForWs;
+
+  var hydrateImageRefs = ctx.hydrateImageRefs;
+  var saveImageFile = ctx.saveImageFile;
+  var imagesDir = ctx.imagesDir;
+
+  var onProcessingChanged = ctx.onProcessingChanged;
+
+  var _loop = ctx._loop;
+  var browserState = ctx.browserState;
+
+  var sendExtensionCommandAny = ctx.sendExtensionCommandAny;
+  var requestTabContext = ctx.requestTabContext;
+
+  var scheduleMessage = ctx.scheduleMessage;
+  var cancelScheduledMessage = ctx.cancelScheduledMessage;
+
+  var loadContextSources = ctx.loadContextSources;
+  var saveContextSources = ctx.saveContextSources;
+
+  var getSDK = ctx.getSDK;
+
+  // --------------- Sticky notes ---------------
+
+  function syncNotesKnowledge() {
+    if (!isMate) return;
+    try {
+      var knDir = path.join(cwd, "knowledge");
+      var knFile = path.join(knDir, "sticky-notes.md");
+      var text = nm.getActiveNotesText();
+      if (text) {
+        fs.mkdirSync(knDir, { recursive: true });
+        fs.writeFileSync(knFile, text);
+      } else {
+        try { fs.unlinkSync(knFile); } catch (e) {}
+      }
+    } catch (e) {
+      console.error("[project] Failed to sync sticky-notes.md:", e.message);
+    }
+  }
+
+  // --------------- Main handler ---------------
+
+  function handleUserMessage(ws, msg) {
+    // --- Sticky notes ---
+    if (msg.type === "note_create") {
+      var note = nm.create(msg);
+      if (note) {
+        send({ type: "note_created", note: note });
+        syncNotesKnowledge();
+      }
+      return true;
+    }
+
+    if (msg.type === "note_update") {
+      if (!msg.id) return true;
+      var updated = nm.update(msg.id, msg);
+      if (updated) {
+        send({ type: "note_updated", note: updated });
+        if (msg.text !== undefined || msg.hidden !== undefined) syncNotesKnowledge();
+      }
+      return true;
+    }
+
+    if (msg.type === "note_delete") {
+      if (!msg.id) return true;
+      if (nm.remove(msg.id)) {
+        send({ type: "note_deleted", id: msg.id });
+        syncNotesKnowledge();
+      }
+      return true;
+    }
+
+    if (msg.type === "note_list_request") {
+      sendTo(ws, { type: "notes_list", notes: nm.list() });
+      return true;
+    }
+
+    if (msg.type === "note_bring_front") {
+      if (!msg.id) return true;
+      var front = nm.bringToFront(msg.id);
+      if (front) send({ type: "note_updated", note: front });
+      return true;
+    }
+
+    // --- Web terminal ---
+    if (msg.type === "term_create") {
+      if (ws._clayUser) {
+        var termPerms = usersModule.getEffectivePermissions(ws._clayUser, osUsers);
+        if (!termPerms.terminal) {
+          sendTo(ws, { type: "term_error", error: "Terminal access is not permitted" });
+          return true;
+        }
+      }
+      var t = tm.create(msg.cols || 80, msg.rows || 24, getOsUserInfoForWs(ws), ws);
+      if (!t) {
+        sendTo(ws, { type: "term_error", error: "Cannot create terminal (node-pty not available or limit reached)" });
+        return true;
+      }
+      tm.attach(t.id, ws);
+      send({ type: "term_list", terminals: tm.list() });
+      sendTo(ws, { type: "term_created", id: t.id });
+      return true;
+    }
+
+    if (msg.type === "term_attach") {
+      if (msg.id) tm.attach(msg.id, ws);
+      return true;
+    }
+
+    if (msg.type === "term_detach") {
+      if (msg.id) tm.detach(msg.id, ws);
+      return true;
+    }
+
+    if (msg.type === "term_input") {
+      if (msg.id) tm.write(msg.id, msg.data);
+      return true;
+    }
+
+    if (msg.type === "term_resize") {
+      if (msg.id && msg.cols > 0 && msg.rows > 0) {
+        tm.resize(msg.id, msg.cols, msg.rows, ws);
+      }
+      return true;
+    }
+
+    if (msg.type === "term_close") {
+      if (msg.id) {
+        tm.close(msg.id);
+        send({ type: "term_list", terminals: tm.list() });
+        // Remove closed terminal from context sources
+        var saved = loadContextSources(slug);
+        var termKey = "term:" + msg.id;
+        var filtered = saved.filter(function(id) { return id !== termKey; });
+        if (filtered.length !== saved.length) {
+          saveContextSources(slug, filtered);
+          send({ type: "context_sources_state", active: filtered });
+        }
+      }
+      return true;
+    }
+
+    if (msg.type === "term_rename") {
+      if (msg.id && msg.title) {
+        tm.rename(msg.id, msg.title);
+        send({ type: "term_list", terminals: tm.list() });
+      }
+      return true;
+    }
+
+    // --- Context Sources ---
+    if (msg.type === "context_sources_save") {
+      var activeIds = msg.active || [];
+      saveContextSources(slug, activeIds);
+      return true;
+    }
+
+    // --- Browser Extension ---
+    if (msg.type === "browser_tab_list") {
+      browserState._extensionWs = ws; // Track which client has the extension
+      var tabs = msg.tabs || [];
+      browserState._browserTabList = {};
+      for (var bti = 0; bti < tabs.length; bti++) {
+        browserState._browserTabList[tabs[bti].id] = tabs[bti];
+      }
+      return true;
+    }
+
+    if (msg.type === "extension_result") {
+      var pending = browserState.pendingExtensionRequests[msg.requestId];
+      if (pending) {
+        clearTimeout(pending.timer);
+        pending.resolve(msg.result);
+        delete browserState.pendingExtensionRequests[msg.requestId];
+      }
+      return true;
+    }
+
+    // --- Scheduled tasks permission gate ---
+    if (msg.type === "loop_start" || msg.type === "loop_stop" || msg.type === "loop_registry_files" ||
+        msg.type === "loop_registry_list" || msg.type === "loop_registry_update" || msg.type === "loop_registry_rename" ||
+        msg.type === "loop_registry_remove" || msg.type === "loop_registry_convert" || msg.type === "loop_registry_toggle" ||
+        msg.type === "loop_registry_rerun" || msg.type === "schedule_create" || msg.type === "schedule_move") {
+      if (ws._clayUser) {
+        var schPerms = usersModule.getEffectivePermissions(ws._clayUser, osUsers);
+        if (!schPerms.scheduledTasks) {
+          sendTo(ws, { type: "error", text: "Scheduled tasks access is not permitted" });
+          return true;
+        }
+      }
+    }
+
+    // --- Loop message delegation (project-loop.js) ---
+    if (_loop.handleLoopMessage(ws, msg)) return true;
+
+    // --- Schedule message for after rate limit resets ---
+    if (msg.type === "schedule_message") {
+      var schedSession = getSessionForWs(ws);
+      if (!schedSession || !msg.text || !msg.resetsAt) return true;
+      scheduleMessage(schedSession, msg.text, msg.resetsAt);
+      return true;
+    }
+
+    if (msg.type === "cancel_scheduled_message") {
+      var cancelSession = getSessionForWs(ws);
+      if (!cancelSession) return true;
+      cancelScheduledMessage(cancelSession);
+      return true;
+    }
+
+    if (msg.type === "send_scheduled_now") {
+      var nowSession = getSessionForWs(ws);
+      if (!nowSession || !nowSession.scheduledMessage) return true;
+      var schedText = nowSession.scheduledMessage.text;
+      clearTimeout(nowSession.scheduledMessage.timer);
+      nowSession.scheduledMessage = null;
+      console.log("[project] Scheduled message sent immediately for session " + nowSession.localId);
+      sm.sendAndRecord(nowSession, { type: "scheduled_message_sent" });
+      var userMsg = { type: "user_message", text: schedText };
+      nowSession.history.push(userMsg);
+      sm.appendToSessionFile(nowSession, userMsg);
+      sendToSession(nowSession.localId, userMsg);
+      nowSession.isProcessing = true;
+      onProcessingChanged();
+      sendToSession(nowSession.localId, { type: "status", status: "processing" });
+      sdk.startQuery(nowSession, schedText, null, getLinuxUserForSession(nowSession));
+      sm.broadcastSessionList();
+      return true;
+    }
+
+    if (msg.type !== "message") return false;
+    if (!msg.text && (!msg.images || msg.images.length === 0) && (!msg.pastes || msg.pastes.length === 0)) return true;
+
+    var session = getSessionForWs(ws);
+    if (!session) return true;
+
+    // Backfill ownerId for legacy sessions restored without one (multi-user only)
+    if (!session.ownerId && ws._clayUser && usersModule.isMultiUser()) {
+      session.ownerId = ws._clayUser.id;
+      sm.saveSessionFile(session);
+    }
+
+    // Keep any pending scheduled message alive when user sends a regular message
+
+    var userMsg2 = { type: "user_message", text: msg.text || "" };
+    // Attach sender info for multi-user attribution (backward-compatible: old clients ignore these)
+    if (ws._clayUser) {
+      userMsg2.from = ws._clayUser.id;
+      userMsg2.fromName = ws._clayUser.displayName || ws._clayUser.username || "";
+    }
+    var savedImagePaths = [];
+    if (msg.images && msg.images.length > 0) {
+      userMsg2.imageCount = msg.images.length;
+      // Save images as files, store URL references in history
+      var imageRefs = [];
+      for (var imgIdx = 0; imgIdx < msg.images.length; imgIdx++) {
+        var img = msg.images[imgIdx];
+        var savedName = saveImageFile(img.mediaType, img.data, getLinuxUserForSession(session));
+        if (savedName) {
+          imageRefs.push({ mediaType: img.mediaType, file: savedName });
+          savedImagePaths.push(path.join(imagesDir, savedName));
+        }
+      }
+      if (imageRefs.length > 0) {
+        userMsg2.imageRefs = imageRefs;
+      }
+    }
+    if (msg.pastes && msg.pastes.length > 0) {
+      userMsg2.pastes = msg.pastes;
+    }
+    session.history.push(userMsg2);
+    sm.appendToSessionFile(session, userMsg2);
+    sendToSessionOthers(ws, session.localId, hydrateImageRefs(userMsg2));
+
+    if (!session.title) {
+      session.title = (msg.text || "Image").substring(0, 50);
+      sm.saveSessionFile(session);
+      sm.broadcastSessionList();
+      // Sync auto-title to SDK
+      if (session.cliSessionId) {
+        getSDK().then(function(sdkMod) {
+          sdkMod.renameSession(session.cliSessionId, session.title, { dir: cwd }).catch(function(e) {
+            console.error("[project] SDK renameSession failed:", e.message);
+          });
+        }).catch(function() {});
+      }
+    }
+
+    var fullText = msg.text || "";
+    // Prepend saved image paths so Claude can copy/save them
+    if (savedImagePaths.length > 0) {
+      var imgPathLines = savedImagePaths.map(function (p) { return "[Uploaded image: " + p + "]"; }).join("\n");
+      fullText = imgPathLines + (fullText ? "\n" + fullText : "");
+    }
+    if (msg.pastes && msg.pastes.length > 0) {
+      for (var pi = 0; pi < msg.pastes.length; pi++) {
+        if (fullText) fullText += "\n\n";
+        fullText += msg.pastes[pi];
+      }
+    }
+
+    // Inject pending @mention context so the current agent sees the exchange
+    if (session.pendingMentionContexts && session.pendingMentionContexts.length > 0) {
+      var mentionPrefix = session.pendingMentionContexts.join("\n\n");
+      session.pendingMentionContexts = [];
+      fullText = mentionPrefix + "\n\n" + fullText;
+    }
+
+    // Inject active terminal context sources (delta only: send new output since last message)
+    var TERM_CONTEXT_MAX = 8192; // 8KB max per terminal per message
+    var TERM_HEAD_SIZE = 2048;   // keep first 2KB for error context
+    var TERM_TAIL_SIZE = 6144;   // keep last 6KB for recent state
+    var ctxSources = loadContextSources(slug);
+    if (ctxSources.length > 0) {
+      if (!session._termContextCursors) session._termContextCursors = {};
+      var termContextParts = [];
+      for (var ci = 0; ci < ctxSources.length; ci++) {
+        var srcId = ctxSources[ci];
+        if (srcId.startsWith("term:")) {
+          var termId = parseInt(srcId.split(":")[1], 10);
+          var sb = tm.getScrollback(termId);
+          if (sb) {
+            var lastCursor;
+            if (termId in session._termContextCursors) {
+              lastCursor = session._termContextCursors[termId];
+              // Terminal was recycled (closed and reopened with same ID) -- reset cursor
+              if (lastCursor > sb.totalBytesWritten) lastCursor = 0;
+            } else {
+              // First time seeing this terminal -- include last 8KB (what user can see now)
+              lastCursor = Math.max(0, sb.totalBytesWritten - TERM_CONTEXT_MAX);
+            }
+            var newBytes = sb.totalBytesWritten - lastCursor;
+            session._termContextCursors[termId] = sb.totalBytesWritten;
+            if (newBytes <= 0) continue;
+            // Build timestamped delta from chunks
+            var deltaChunks = [];
+            var bytePos = sb.bufferStart;
+            for (var chunkIdx = 0; chunkIdx < sb.chunks.length; chunkIdx++) {
+              var chunk = sb.chunks[chunkIdx];
+              var chunkEnd = bytePos + chunk.data.length;
+              if (chunkEnd > lastCursor) {
+                // This chunk has new content
+                var chunkData = chunk.data;
+                if (bytePos < lastCursor) {
+                  // Partial chunk: only the part after lastCursor
+                  chunkData = chunkData.slice(lastCursor - bytePos);
+                }
+                deltaChunks.push({ ts: chunk.ts, data: chunkData });
+              }
+              bytePos = chunkEnd;
+            }
+            if (deltaChunks.length === 0) continue;
+            // Format with timestamps: group by second to avoid excessive timestamps
+            var lines = [];
+            var lastTimeSec = 0;
+            for (var di = 0; di < deltaChunks.length; di++) {
+              var dc = deltaChunks[di];
+              var cleaned = dc.data.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+              if (!cleaned) continue;
+              var timeSec = Math.floor(dc.ts / 1000);
+              if (timeSec !== lastTimeSec) {
+                var d = new Date(dc.ts);
+                var timeStr = d.toTimeString().slice(0, 8); // HH:MM:SS
+                lines.push("[" + timeStr + "] " + cleaned);
+                lastTimeSec = timeSec;
+              } else {
+                lines.push(cleaned);
+              }
+            }
+            var delta = lines.join("").trim();
+            if (!delta) continue;
+            var termInfo = tm.list().find(function(t) { return t.id === termId; });
+            var termTitle = termInfo ? termInfo.title : "Terminal " + termId;
+            var header;
+            if (delta.length > TERM_CONTEXT_MAX) {
+              var head = delta.slice(0, TERM_HEAD_SIZE);
+              var tail = delta.slice(-TERM_TAIL_SIZE);
+              var omittedBytes = delta.length - TERM_HEAD_SIZE - TERM_TAIL_SIZE;
+              var omittedLines = delta.slice(TERM_HEAD_SIZE, delta.length - TERM_TAIL_SIZE).split("\n").length;
+              delta = head + "\n\n... (" + omittedLines + " lines / " + Math.round(omittedBytes / 1024) + "KB omitted) ...\n\n" + tail;
+              header = "[New terminal output from " + termTitle + " (large output, head+tail shown)]";
+            } else {
+              header = "[New terminal output from " + termTitle + "]";
+            }
+            termContextParts.push(header + "\n```\n" + delta + "\n```");
+          }
+        }
+      }
+      if (termContextParts.length > 0) {
+        fullText = termContextParts.join("\n\n") + "\n\n" + fullText;
+      }
+    }
+
+    // Collect browser tab context (async: requires round-trip to client extension)
+    var _browserTabList = browserState._browserTabList;
+    var tabSources = ctxSources.filter(function(id) {
+      if (!id.startsWith("tab:")) return false;
+      // Only include tabs that currently exist in the browser
+      var tid = parseInt(id.split(":")[1], 10);
+      return !!_browserTabList[tid];
+    });
+
+    function dispatchToSdk(finalText) {
+      if (!session.isProcessing) {
+        session.isProcessing = true;
+        onProcessingChanged();
+        session.sentToolResults = {};
+        sendToSession(session.localId, { type: "status", status: "processing" });
+        if (!session.queryInstance && (!session.worker || session.messageQueue !== "worker")) {
+          // No active query (or worker idle between queries): start a new query
+          session._queryStartTs = Date.now();
+          console.log("[PERF] project.js: startQuery called, localId=" + session.localId + " t=0ms");
+          sdk.startQuery(session, finalText, msg.images, getLinuxUserForSession(session));
+        } else {
+          sdk.pushMessage(session, finalText, msg.images);
+        }
+      } else {
+        sdk.pushMessage(session, finalText, msg.images);
+      }
+      sm.broadcastSessionList();
+    }
+
+    if (tabSources.length > 0) {
+      // Request tab context from all active browser tab sources
+      var tabPromises = tabSources.map(function(srcId) {
+        var tabId = parseInt(srcId.split(":")[1], 10);
+        return requestTabContext(ws, tabId);
+      });
+      Promise.all(tabPromises).then(function(results) {
+        var tabContextParts = [];
+        var screenshotImages = [];
+
+        for (var ti = 0; ti < results.length; ti++) {
+          if (!results[ti]) continue;
+          var tabId2 = parseInt(tabSources[ti].split(":")[1], 10);
+          var tabInfo = _browserTabList[tabId2];
+          var tabLabel = tabInfo ? (tabInfo.title || tabInfo.url || "Tab " + tabId2) : "Tab " + tabId2;
+          var r = results[ti];
+          var parts = [];
+
+          // Console logs
+          if (r.console && r.console.logs) {
+            try {
+              var logs = typeof r.console.logs === "string" ? JSON.parse(r.console.logs) : r.console.logs;
+              if (logs && logs.length > 0) {
+                var logLines = [];
+                var logSlice = logs.slice(-50);
+                for (var li = 0; li < logSlice.length; li++) {
+                  var entry = logSlice[li];
+                  var ts = entry.ts ? new Date(entry.ts).toTimeString().slice(0, 8) : "";
+                  var lvl = (entry.level || "log").toUpperCase();
+                  logLines.push("[" + ts + " " + lvl + "] " + (entry.text || ""));
+                }
+                parts.push("Console:\n" + logLines.join("\n"));
+              }
+            } catch (e) {
+              // ignore parse errors
+            }
+          }
+
+          // Network requests
+          if (r.network && r.network.network) {
+            try {
+              var netLog = typeof r.network.network === "string" ? JSON.parse(r.network.network) : r.network.network;
+              if (netLog && netLog.length > 0) {
+                var netLines = [];
+                var netSlice = netLog.slice(-30);
+                for (var ni = 0; ni < netSlice.length; ni++) {
+                  var req = netSlice[ni];
+                  var line = (req.method || "GET") + " " + (req.url || "") + " " + (req.status || 0) + " " + (req.duration || 0) + "ms";
+                  if (req.error) line += " [" + req.error + "]";
+                  netLines.push(line);
+                }
+                parts.push("Network (last " + netSlice.length + " requests):\n" + netLines.join("\n"));
+              }
+            } catch (e) {
+              // ignore parse errors
+            }
+          }
+
+          // Page text (from tab_page_text command)
+          if (r.pageText && (r.pageText.text || r.pageText.value)) {
+            var pageContent = r.pageText.text || r.pageText.value;
+            if (pageContent.length > 0) {
+              if (pageContent.length > 32768) {
+                pageContent = pageContent.substring(0, 32768) + "\n... (truncated)";
+              }
+              parts.push("Page text:\n" + pageContent);
+            }
+          }
+
+          // Screenshot -- save to disk and add to images for SDK
+          if (r.screenshot && r.screenshot.image) {
+            try {
+              var screenshotData = r.screenshot.image;
+              var screenshotName = saveImageFile("image/png", screenshotData, getLinuxUserForSession(session));
+              if (screenshotName) {
+                var screenshotPath = path.join(imagesDir, screenshotName);
+                // Add to images array for SDK multimodal
+                screenshotImages.push({
+                  mediaType: "image/png",
+                  data: screenshotData,
+                  file: screenshotName,
+                  tabTitle: tabLabel,
+                  tabUrl: tabInfo ? tabInfo.url : "",
+                  tabFavIconUrl: tabInfo ? tabInfo.favIconUrl : ""
+                });
+                parts.push("[Screenshot saved: " + screenshotPath + "]");
+              }
+            } catch (e) {
+              // ignore screenshot save errors
+            }
+          }
+
+          if (r.console && r.console.error) {
+            parts.push("(Console error: " + r.console.error + ")");
+          }
+          if (r.network && r.network.error) {
+            parts.push("(Network error: " + r.network.error + ")");
+          }
+
+          if (parts.length > 0) {
+            tabContextParts.push("[Browser tab: " + tabLabel + "]\n" + parts.join("\n\n"));
+          }
+        }
+
+        if (tabContextParts.length > 0) {
+          fullText = "[The following browser tab data is automatically attached as context sources. Do NOT call browser_read_page, browser_console, browser_network, or browser_screenshot for these tabs -- the data is already here.]\n\n" +
+            tabContextParts.join("\n\n---\n\n") + "\n\n" + fullText;
+        }
+
+        // If screenshots were captured, send context preview cards and add to SDK images
+        if (screenshotImages.length > 0) {
+          if (!msg.images) msg.images = [];
+          for (var si = 0; si < screenshotImages.length; si++) {
+            var ss = screenshotImages[si];
+            // Save context_preview to history so it restores on session load
+            var previewEntry = {
+              type: "context_preview",
+              tab: {
+                title: ss.tabTitle || "",
+                url: ss.tabUrl || "",
+                favIconUrl: ss.tabFavIconUrl || "",
+                screenshotFile: ss.file
+              }
+            };
+            session.history.push(previewEntry);
+            // Send context card to all clients
+            sendToSession(session.localId, {
+              type: "context_preview",
+              tab: {
+                title: ss.tabTitle || "",
+                url: ss.tabUrl || "",
+                favIconUrl: ss.tabFavIconUrl || "",
+                screenshotUrl: "/p/" + slug + "/images/" + ss.file
+              }
+            });
+            // Add to SDK images for multimodal
+            msg.images.push({ mediaType: ss.mediaType, data: ss.data });
+          }
+          sm.saveSessionFile(session);
+        }
+
+        dispatchToSdk(fullText);
+      });
+    } else {
+      dispatchToSdk(fullText);
+    }
+
+    return true;
+  }
+
+  return {
+    handleUserMessage: handleUserMessage,
+    syncNotesKnowledge: syncNotesKnowledge,
+  };
+}
+
+module.exports = { attachUserMessage: attachUserMessage };