clay-server 2.27.0-beta.8 → 2.27.0

package/lib/server-dm.js

@@ -0,0 +1,221 @@
+var fs = require("fs");
+
+function attachDm(ctx) {
+  var users = ctx.users;
+  var dm = ctx.dm;
+  var mates = ctx.mates;
+  var projects = ctx.projects;
+  var pushModule = ctx.pushModule;
+  var addProject = ctx.addProject;
+
+  function handleMessage(ws, msg) {
+    if (!users.isMultiUser() || !ws._clayUser) return false;
+    var userId = ws._clayUser.id;
+
+    if (msg.type === "dm_list") {
+      var dmList = dm.getDmList(userId);
+      // Enrich with user info
+      for (var i = 0; i < dmList.length; i++) {
+        var otherUser = users.findUserById(dmList[i].otherUserId);
+        if (otherUser) {
+          var p = otherUser.profile || {};
+          dmList[i].otherUser = {
+            id: otherUser.id,
+            displayName: p.name || otherUser.displayName || otherUser.username,
+            username: otherUser.username,
+            avatarStyle: p.avatarStyle || "thumbs",
+            avatarSeed: p.avatarSeed || otherUser.username,
+            avatarColor: p.avatarColor || "#7c3aed",
+            avatarCustom: p.avatarCustom || "",
+          };
+        }
+      }
+      // Include mates in the list
+      var mateCtx = mates.buildMateCtx(userId);
+      var mateList = mates.getAllMates(mateCtx);
+      ws.send(JSON.stringify({ type: "dm_list", dms: dmList, mates: mateList }));
+      return true;
+    }
+
+    if (msg.type === "dm_open") {
+      if (!msg.targetUserId) return true;
+
+      // Check if target is a mate
+      var mateCtx2 = mates.buildMateCtx(userId);
+      if (mates.isMate(mateCtx2, msg.targetUserId)) {
+        var mate = mates.getMate(mateCtx2, msg.targetUserId);
+        if (!mate) return true;
+        // Ensure mate project is registered (survives server restarts)
+        var mateSlug2 = "mate-" + mate.id;
+        if (!projects.has(mateSlug2)) {
+          var mateDir2 = mates.getMateDir(mateCtx2, mate.id);
+          fs.mkdirSync(mateDir2, { recursive: true });
+          var mateName2 = (mate.profile && mate.profile.displayName) || mate.name || "New Mate";
+          addProject(mateDir2, mateSlug2, mateName2, null, mate.createdBy || userId, null, { isMate: true, mateDisplayName: mateName2 });
+        }
+        var mp = mate.profile || {};
+        ws.send(JSON.stringify({
+          type: "dm_history",
+          dmKey: "mate:" + mate.id,
+          messages: dm.loadHistory("mate:" + mate.id),
+          isMate: true,
+          projectSlug: mateSlug2,
+          targetUser: {
+            id: mate.id,
+            displayName: mp.displayName || mate.name || "New Mate",
+            username: mate.id,
+            avatarStyle: mp.avatarStyle || "bottts",
+            avatarSeed: mp.avatarSeed || mate.id,
+            avatarColor: mp.avatarColor || "#6c5ce7",
+            avatarCustom: mp.avatarCustom || "",
+            isMate: true,
+            primary: !!mate.primary,
+            mateStatus: mate.status,
+            seedData: mate.seedData || {},
+          },
+        }));
+        return true;
+      }
+
+      var result = dm.openDm(userId, msg.targetUserId);
+      var targetUser = users.findUserById(msg.targetUserId);
+      var tp = targetUser ? (targetUser.profile || {}) : {};
+      ws.send(JSON.stringify({
+        type: "dm_history",
+        dmKey: result.dmKey,
+        messages: result.messages,
+        targetUser: targetUser ? {
+          id: targetUser.id,
+          displayName: tp.name || targetUser.displayName || targetUser.username,
+          username: targetUser.username,
+          avatarStyle: tp.avatarStyle || "thumbs",
+          avatarSeed: tp.avatarSeed || targetUser.username,
+          avatarColor: tp.avatarColor || "#7c3aed",
+          avatarCustom: tp.avatarCustom || "",
+        } : null,
+      }));
+      return true;
+    }
+
+    if (msg.type === "dm_typing") {
+      // Relay typing indicator to DM partner
+      var dmKey = msg.dmKey;
+      if (!dmKey) return true;
+      var parts = dmKey.split(":");
+      if (parts.indexOf(userId) === -1) return true;
+      var targetId = parts[0] === userId ? parts[1] : parts[0];
+      projects.forEach(function (ctx) {
+        ctx.forEachClient(function (otherWs) {
+          if (otherWs === ws) return;
+          if (!otherWs._clayUser || otherWs._clayUser.id !== targetId) return;
+          if (otherWs.readyState !== 1) return;
+          otherWs.send(JSON.stringify({ type: "dm_typing", dmKey: dmKey, userId: userId, typing: !!msg.typing }));
+        });
+      });
+      return true;
+    }
+
+    if (msg.type === "dm_send") {
+      if (!msg.dmKey || !msg.text) return true;
+      var parts = msg.dmKey.split(":");
+
+      // Handle mate DM: dmKey is "mate:mate_xxx"
+      var mateCtx3 = mates.buildMateCtx(userId);
+      if (parts[0] === "mate" && mates.isMate(mateCtx3, parts[1])) {
+        var mate = mates.getMate(mateCtx3, parts[1]);
+        if (!mate) return true;
+        // Verify sender is the mate's creator
+        if (mate.createdBy !== userId) return true;
+        var message = dm.sendMessage(msg.dmKey, userId, msg.text);
+        ws.send(JSON.stringify({ type: "dm_message", dmKey: msg.dmKey, message: message }));
+        return true;
+      }
+
+      // Regular DM: verify sender is a participant
+      if (parts.indexOf(userId) === -1) return true;
+      var message = dm.sendMessage(msg.dmKey, userId, msg.text);
+      // Send confirmation to sender
+      ws.send(JSON.stringify({ type: "dm_message", dmKey: msg.dmKey, message: message }));
+      // Broadcast to target user's connections across all projects
+      var targetId = parts[0] === userId ? parts[1] : parts[0];
+      projects.forEach(function (ctx) {
+        ctx.forEachClient(function (otherWs) {
+          if (otherWs === ws) return;
+          if (!otherWs._clayUser || otherWs._clayUser.id !== targetId) return;
+          if (otherWs.readyState !== 1) return;
+          otherWs.send(JSON.stringify({ type: "dm_message", dmKey: msg.dmKey, message: message }));
+        });
+      });
+      // Send push notification to target user
+      var senderName = ws._clayUser ? (ws._clayUser.displayName || ws._clayUser.username || "Someone") : "Someone";
+      var preview = (msg.text || "").substring(0, 140);
+      if (pushModule && pushModule.sendPushToUser) {
+        pushModule.sendPushToUser(targetId, {
+          type: "dm",
+          title: senderName,
+          body: preview,
+          tag: "dm-" + msg.dmKey,
+          dmKey: msg.dmKey,
+        });
+      }
+      // Create in-app notification via any project's notifications module
+      var _nmCtx = null;
+      projects.forEach(function (pCtx) { if (!_nmCtx && pCtx.getNotificationsModule) _nmCtx = pCtx; });
+      if (_nmCtx) {
+        var _nm = _nmCtx.getNotificationsModule();
+        if (_nm) {
+          _nm.notify("mate_dm", {
+            senderName: senderName,
+            preview: preview,
+            mateId: userId,
+          });
+        }
+      }
+      return true;
+    }
+
+    if (msg.type === "dm_add_favorite") {
+      if (!msg.targetUserId) return true;
+      users.removeDmHidden(userId, msg.targetUserId);
+      var updatedFavorites = users.addDmFavorite(userId, msg.targetUserId);
+      var allUsersList = users.getAllUsers().map(function (u) {
+        var p = u.profile || {};
+        return {
+          id: u.id,
+          displayName: p.name || u.displayName || u.username,
+          username: u.username,
+          role: u.role,
+          avatarStyle: p.avatarStyle || "thumbs",
+          avatarSeed: p.avatarSeed || u.username,
+          avatarColor: p.avatarColor || "#7c3aed",
+          avatarCustom: p.avatarCustom || "",
+        };
+      });
+      ws.send(JSON.stringify({
+        type: "dm_favorites_updated",
+        dmFavorites: updatedFavorites,
+        allUsers: allUsersList,
+      }));
+      return true;
+    }
+
+    if (msg.type === "dm_remove_favorite") {
+      if (!msg.targetUserId) return true;
+      users.addDmHidden(userId, msg.targetUserId);
+      var updatedFavorites = users.removeDmFavorite(userId, msg.targetUserId);
+      ws.send(JSON.stringify({
+        type: "dm_favorites_updated",
+        dmFavorites: updatedFavorites,
+      }));
+      return true;
+    }
+
+    return false;
+  }
+
+  return {
+    handleMessage: handleMessage,
+  };
+}
+
+module.exports = { attachDm: attachDm };

package/lib/server-mates.js

@@ -0,0 +1,281 @@
+var fs = require("fs");
+var path = require("path");
+
+function attachMates(ctx) {
+  var users = ctx.users;
+  var mates = ctx.mates;
+  var projects = ctx.projects;
+  var addProject = ctx.addProject;
+  var removeProject = ctx.removeProject;
+  var onGetProjectAccess = ctx.onGetProjectAccess;
+
+  // --- Team section enforcement ---
+
+  function refreshTeamSections(mateCtx) {
+    try {
+      var allMates = mates.getAllMates(mateCtx);
+      // Collect non-mate projects accessible to this user
+      var userId = mateCtx.userId || null;
+      var projList = [];
+      projects.forEach(function (pCtx, pSlug) {
+        var st = pCtx.getStatus();
+        if (st.isMate || st.isWorktree) return;
+        // Filter by user access in multi-user mode
+        if (userId && users.isMultiUser() && onGetProjectAccess) {
+          var access = onGetProjectAccess(pSlug);
+          if (access && !access.error && !users.canAccessProject(userId, access)) return;
+        }
+        projList.push(st);
+      });
+      for (var ri = 0; ri < allMates.length; ri++) {
+        var mDir = mates.getMateDir(mateCtx, allMates[ri].id);
+        var claudePath = path.join(mDir, "CLAUDE.md");
+        try {
+          mates.enforceAllSections(claudePath, { ctx: mateCtx, mateId: allMates[ri].id, projects: projList });
+        } catch (e) {}
+      }
+    } catch (e) {
+      console.error("[mates] refreshTeamSections failed:", e.message);
+    }
+  }
+
+  // Debounced project registry refresh for all mates
+  var _registryRefreshTimer = null;
+  function scheduleRegistryRefresh() {
+    if (_registryRefreshTimer) clearTimeout(_registryRefreshTimer);
+    _registryRefreshTimer = setTimeout(function () {
+      _registryRefreshTimer = null;
+      // Refresh for all known user contexts
+      try {
+        var allCtxs = {};
+        projects.forEach(function (pCtx) {
+          var st = pCtx.getStatus();
+          if (st.projectOwnerId && !allCtxs[st.projectOwnerId]) {
+            allCtxs[st.projectOwnerId] = mates.buildMateCtx(st.projectOwnerId);
+          }
+        });
+        var ctxKeys = Object.keys(allCtxs);
+        for (var ci = 0; ci < ctxKeys.length; ci++) {
+          refreshTeamSections(allCtxs[ctxKeys[ci]]);
+        }
+      } catch (e) {}
+    }, 2000);
+  }
+
+  // --- Mate message handlers ---
+
+  function handleMessage(ws, msg) {
+    if (!users.isMultiUser() || !ws._clayUser) return false;
+    var userId = ws._clayUser.id;
+
+    if (msg.type === "mate_create") {
+      if (!msg.seedData) return true;
+      try {
+        var mateCtx4 = mates.buildMateCtx(userId);
+        var mate = mates.createMate(mateCtx4, msg.seedData);
+        // Register mate as a project
+        var mateDir = mates.getMateDir(mateCtx4, mate.id);
+        var mateSlug = "mate-" + mate.id;
+        var mateName = (mate.profile && mate.profile.displayName) || mate.name || "New Mate";
+        addProject(mateDir, mateSlug, mateName, null, mate.createdBy, null, { isMate: true, mateDisplayName: mateName });
+        // Auto-add to favorites so it shows in sidebar
+        users.addDmFavorite(userId, mate.id);
+        ws.send(JSON.stringify({ type: "mate_created", mate: mate, projectSlug: mateSlug }));
+      } catch (e) {
+        ws.send(JSON.stringify({ type: "mate_error", error: "Failed to create mate: " + e.message }));
+      }
+      return true;
+    }
+
+    if (msg.type === "mate_list") {
+      var mateCtx5 = mates.buildMateCtx(userId);
+      // Backfill built-in mates for existing users
+      try {
+        var deletedKeys = users.getDeletedBuiltinKeys(userId);
+        var newBuiltins = mates.ensureBuiltinMates(mateCtx5, deletedKeys);
+        for (var bi = 0; bi < newBuiltins.length; bi++) {
+          var nb = newBuiltins[bi];
+          var nbSlug = "mate-" + nb.id;
+          var nbDir = mates.getMateDir(mateCtx5, nb.id);
+          var nbName = (nb.profile && nb.profile.displayName) || nb.name || "New Mate";
+          addProject(nbDir, nbSlug, nbName, null, nb.createdBy || userId, null, { isMate: true, mateDisplayName: nbName });
+          users.addDmFavorite(userId, nb.id);
+        }
+      } catch (e) {
+        console.error("[server] Failed to ensure built-in mates:", e.message);
+      }
+      // Auto-sync primary mates (Ally) with latest definition
+      try { mates.syncPrimaryMates(mateCtx5); } catch (e) {}
+      // Ensure core built-in mates are in favorites (unless user explicitly removed them)
+      // Only auto-favorite the core 3: Ally (chief of staff), Arch (architect), Buzz (marketer)
+      var coreMateKeys = ["ally", "arch", "buzz"];
+      var mateList = mates.getAllMates(mateCtx5);
+      var currentFavs = users.getDmFavorites(userId);
+      var hiddenIds = users.getDmHidden(userId);
+      for (var bfi = 0; bfi < mateList.length; bfi++) {
+        if (mateList[bfi].builtinKey && coreMateKeys.indexOf(mateList[bfi].builtinKey) !== -1 && currentFavs.indexOf(mateList[bfi].id) === -1 && hiddenIds.indexOf(mateList[bfi].id) === -1) {
+          users.addDmFavorite(userId, mateList[bfi].id);
+        }
+      }
+      // Ensure all mate projects are registered (survives server restarts)
+      for (var mi = 0; mi < mateList.length; mi++) {
+        var m = mateList[mi];
+        var mSlug = "mate-" + m.id;
+        if (!projects.has(mSlug)) {
+          var mDir = mates.getMateDir(mateCtx5, m.id);
+          fs.mkdirSync(mDir, { recursive: true });
+          var mName = (m.profile && m.profile.displayName) || m.name || "New Mate";
+          addProject(mDir, mSlug, mName, null, m.createdBy || userId, null, { isMate: true, mateDisplayName: mName });
+        }
+      }
+      // Include deleted built-in mates for re-add UI
+      var builtinDefs2 = require("./builtin-mates");
+      var missingKeys2 = mates.getMissingBuiltinKeys(mateCtx5);
+      var availableBuiltins2 = [];
+      for (var abk2 = 0; abk2 < missingKeys2.length; abk2++) {
+        var bDef2 = builtinDefs2.getBuiltinByKey(missingKeys2[abk2]);
+        if (bDef2) {
+          availableBuiltins2.push({
+            key: bDef2.key,
+            displayName: bDef2.displayName,
+            bio: bDef2.bio,
+            avatarCustom: bDef2.avatarCustom || "",
+            avatarStyle: bDef2.avatarStyle || "bottts",
+            avatarColor: bDef2.avatarColor || "",
+          });
+        }
+      }
+      ws.send(JSON.stringify({ type: "mate_list", mates: mateList, availableBuiltins: availableBuiltins2 }));
+      return true;
+    }
+
+    if (msg.type === "mate_delete") {
+      if (!msg.mateId) return true;
+      var mateCtx6 = mates.buildMateCtx(userId);
+      // Track deleted built-in mate key so it doesn't auto-recreate
+      var mateToDelete = mates.getMate(mateCtx6, msg.mateId);
+      if (mateToDelete && mateToDelete.builtinKey) {
+        users.addDeletedBuiltinKey(userId, mateToDelete.builtinKey);
+      }
+      var result = mates.deleteMate(mateCtx6, msg.mateId);
+      if (result.error) {
+        ws.send(JSON.stringify({ type: "mate_error", error: result.error }));
+      } else {
+        removeProject("mate-" + msg.mateId);
+        // Build updated available builtins list
+        var builtinDefs3 = require("./builtin-mates");
+        var missingKeys3 = mates.getMissingBuiltinKeys(mateCtx6);
+        var availableBuiltins3 = [];
+        for (var abk3 = 0; abk3 < missingKeys3.length; abk3++) {
+          var bDef3 = builtinDefs3.getBuiltinByKey(missingKeys3[abk3]);
+          if (bDef3) {
+            availableBuiltins3.push({
+              key: bDef3.key,
+              displayName: bDef3.displayName,
+              bio: bDef3.bio,
+              avatarCustom: bDef3.avatarCustom || "",
+              avatarStyle: bDef3.avatarStyle || "bottts",
+              avatarColor: bDef3.avatarColor || "",
+            });
+          }
+        }
+        ws.send(JSON.stringify({ type: "mate_deleted", mateId: msg.mateId, availableBuiltins: availableBuiltins3 }));
+        // Broadcast to all clients so strips update
+        projects.forEach(function (pCtx) {
+          pCtx.forEachClient(function (otherWs) {
+            if (otherWs === ws) return;
+            if (otherWs.readyState !== 1) return;
+            otherWs.send(JSON.stringify({ type: "mate_deleted", mateId: msg.mateId, availableBuiltins: availableBuiltins3 }));
+          });
+        });
+      }
+      return true;
+    }
+
+    if (msg.type === "mate_readd_builtin") {
+      if (!msg.builtinKey) return true;
+      try {
+        var mateCtxR = mates.buildMateCtx(userId);
+        var missingKeys = mates.getMissingBuiltinKeys(mateCtxR);
+        if (missingKeys.indexOf(msg.builtinKey) === -1) {
+          ws.send(JSON.stringify({ type: "mate_error", error: "This built-in mate already exists" }));
+          return true;
+        }
+        var newMate = mates.createBuiltinMate(mateCtxR, msg.builtinKey);
+        users.removeDeletedBuiltinKey(userId, msg.builtinKey);
+        var updatedFavsR = users.addDmFavorite(userId, newMate.id);
+        var readdSlug = "mate-" + newMate.id;
+        var readdDir = mates.getMateDir(mateCtxR, newMate.id);
+        var readdName = (newMate.profile && newMate.profile.displayName) || newMate.name || "New Mate";
+        addProject(readdDir, readdSlug, readdName, null, newMate.createdBy || userId, null, { isMate: true, mateDisplayName: readdName });
+        // Build updated available builtins
+        var builtinDefsR = require("./builtin-mates");
+        var missingKeysR = mates.getMissingBuiltinKeys(mateCtxR);
+        var availableBuiltinsR = [];
+        for (var abkR = 0; abkR < missingKeysR.length; abkR++) {
+          var bDefR = builtinDefsR.getBuiltinByKey(missingKeysR[abkR]);
+          if (bDefR) {
+            availableBuiltinsR.push({ key: bDefR.key, displayName: bDefR.displayName, bio: bDefR.bio, avatarCustom: bDefR.avatarCustom || "", avatarStyle: bDefR.avatarStyle || "bottts", avatarColor: bDefR.avatarColor || "" });
+          }
+        }
+        ws.send(JSON.stringify({ type: "mate_created", mate: newMate, projectSlug: readdSlug, availableBuiltins: availableBuiltinsR, dmFavorites: updatedFavsR }));
+      } catch (e) {
+        ws.send(JSON.stringify({ type: "mate_error", error: "Failed to re-add built-in mate: " + e.message }));
+      }
+      return true;
+    }
+
+    if (msg.type === "mate_list_available_builtins") {
+      var mateCtxAB = mates.buildMateCtx(userId);
+      var missingBuiltinKeys = mates.getMissingBuiltinKeys(mateCtxAB);
+      var builtinDefs = require("./builtin-mates");
+      var availableBuiltins = [];
+      for (var abk = 0; abk < missingBuiltinKeys.length; abk++) {
+        var bDef = builtinDefs.getBuiltinByKey(missingBuiltinKeys[abk]);
+        if (bDef) {
+          availableBuiltins.push({
+            key: bDef.key,
+            displayName: bDef.displayName,
+            bio: bDef.bio,
+            avatarColor: bDef.avatarColor,
+            avatarStyle: bDef.avatarStyle,
+            avatarCustom: bDef.avatarCustom || "",
+          });
+        }
+      }
+      ws.send(JSON.stringify({ type: "mate_available_builtins", builtins: availableBuiltins }));
+      return true;
+    }
+
+    if (msg.type === "mate_update") {
+      if (!msg.mateId || !msg.updates) return true;
+      var mateCtx7 = mates.buildMateCtx(userId);
+      var updated = mates.updateMate(mateCtx7, msg.mateId, msg.updates);
+      if (updated) {
+        ws.send(JSON.stringify({ type: "mate_updated", mate: updated }));
+        // Broadcast update
+        projects.forEach(function (pCtx) {
+          pCtx.forEachClient(function (otherWs) {
+            if (otherWs === ws) return;
+            if (otherWs.readyState !== 1) return;
+            otherWs.send(JSON.stringify({ type: "mate_updated", mate: updated }));
+          });
+        });
+        // Re-enforce team sections across all mate projects so roster stays current
+        refreshTeamSections(mateCtx7);
+      } else {
+        ws.send(JSON.stringify({ type: "mate_error", error: "Mate not found" }));
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  return {
+    handleMessage: handleMessage,
+    scheduleRegistryRefresh: scheduleRegistryRefresh,
+  };
+}
+
+module.exports = { attachMates: attachMates };

package/lib/server-palette.js

@@ -0,0 +1,110 @@
+var sessionSearch = require("./session-search");
+
+function attachPalette(ctx) {
+  var users = ctx.users;
+  var projects = ctx.projects;
+  var getMultiUserFromReq = ctx.getMultiUserFromReq;
+  var onGetProjectAccess = ctx.onGetProjectAccess;
+
+  function handleRequest(req, res, fullUrl) {
+    if (req.method !== "GET" || fullUrl !== "/api/palette/search") return false;
+
+    var paletteUser = null;
+    if (users.isMultiUser()) {
+      paletteUser = getMultiUserFromReq(req);
+      if (!paletteUser) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end('{"error":"unauthorized"}');
+        return true;
+      }
+    }
+    var pqs = req.url.indexOf("?") >= 0 ? req.url.substring(req.url.indexOf("?")) : "";
+    var pQuery = new URLSearchParams(pqs).get("q") || "";
+    var pResults = [];
+
+    if (!pQuery) {
+      // Recent mode: return all sessions sorted by lastActivity
+      projects.forEach(function (pCtx, pSlug) {
+        var status = pCtx.getStatus();
+        if (status.isWorktree) return;
+        if (paletteUser && onGetProjectAccess) {
+          var pAccess = onGetProjectAccess(pSlug);
+          if (pAccess && !pAccess.error && !users.canAccessProject(paletteUser.id, pAccess)) return;
+        }
+        pCtx.sm.sessions.forEach(function (session) {
+          if (session.hidden) return;
+          if (paletteUser) {
+            if (users.isMultiUser()) {
+              var sAccess = onGetProjectAccess ? onGetProjectAccess(pSlug) : null;
+              if (!users.canAccessSession(paletteUser.id, session, sAccess)) return;
+            }
+          } else {
+            if (session.ownerId) return;
+          }
+          var pItem = {
+            projectSlug: pSlug,
+            projectTitle: status.title || status.project,
+            projectIcon: status.icon || null,
+            sessionId: session.localId,
+            sessionTitle: session.title || "New Session",
+            lastActivity: session.lastActivity || session.createdAt || 0,
+            matchType: null,
+            snippet: null
+          };
+          if (status.isMate) {
+            pItem.isMate = true;
+            pItem.mateId = status.mateId || null;
+          }
+          pResults.push(pItem);
+        });
+      });
+      pResults.sort(function (a, b) { return b.lastActivity - a.lastActivity; });
+      if (pResults.length > 30) pResults = pResults.slice(0, 30);
+    } else {
+      // Search mode: BM25 ranked search across all sessions
+      var projectSessions = [];
+      projects.forEach(function (pCtx, pSlug) {
+        var status = pCtx.getStatus();
+        if (status.isWorktree) return;
+        if (paletteUser && onGetProjectAccess) {
+          var pAccess = onGetProjectAccess(pSlug);
+          if (pAccess && !pAccess.error && !users.canAccessProject(paletteUser.id, pAccess)) return;
+        }
+        var accessibleSessions = [];
+        pCtx.sm.sessions.forEach(function (session) {
+          if (session.hidden) return;
+          if (paletteUser) {
+            if (users.isMultiUser()) {
+              var sAccess = onGetProjectAccess ? onGetProjectAccess(pSlug) : null;
+              if (!users.canAccessSession(paletteUser.id, session, sAccess)) return;
+            }
+          } else {
+            if (session.ownerId) return;
+          }
+          accessibleSessions.push(session);
+        });
+        if (accessibleSessions.length > 0) {
+          projectSessions.push({
+            projectSlug: pSlug,
+            projectTitle: status.title || status.project,
+            projectIcon: status.icon || null,
+            isMate: status.isMate || false,
+            mateId: status.mateId || null,
+            sessions: accessibleSessions
+          });
+        }
+      });
+      pResults = sessionSearch.searchPalette(projectSessions, pQuery, { maxResults: 30 });
+    }
+
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ results: pResults }));
+    return true;
+  }
+
+  return {
+    handleRequest: handleRequest,
+  };
+}
+
+module.exports = { attachPalette: attachPalette };