totem-llm 0.1.0

package/server/endpoints/browserExtension.js

@@ -0,0 +1,221 @@
+const { Workspace } = require("../models/workspace");
+const { BrowserExtensionApiKey } = require("../models/browserExtensionApiKey");
+const { Document } = require("../models/documents");
+const {
+  validBrowserExtensionApiKey,
+} = require("../utils/middleware/validBrowserExtensionApiKey");
+const { CollectorApi } = require("../utils/collectorApi");
+const { reqBody, multiUserMode, userFromSession } = require("../utils/http");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../utils/middleware/multiUserProtected");
+
+function browserExtensionEndpoints(app) {
+  if (!app) return;
+
+  app.get(
+    "/browser-extension/check",
+    [validBrowserExtensionApiKey],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const workspaces = multiUserMode(response)
+          ? await Workspace.whereWithUser(user)
+          : await Workspace.where();
+
+        const apiKeyId = response.locals.apiKey.id;
+        response.status(200).json({
+          connected: true,
+          workspaces,
+          apiKeyId,
+        });
+      } catch (error) {
+        console.error(error);
+        response
+          .status(500)
+          .json({ connected: false, error: "Failed to fetch workspaces" });
+      }
+    }
+  );
+
+  app.delete(
+    "/browser-extension/disconnect",
+    [validBrowserExtensionApiKey],
+    async (_request, response) => {
+      try {
+        const apiKeyId = response.locals.apiKey.id;
+        const { success, error } =
+          await BrowserExtensionApiKey.delete(apiKeyId);
+        if (!success) throw new Error(error);
+        response.status(200).json({ success: true });
+      } catch (error) {
+        console.error(error);
+        response
+          .status(500)
+          .json({ error: "Failed to disconnect and revoke API key" });
+      }
+    }
+  );
+
+  app.get(
+    "/browser-extension/workspaces",
+    [validBrowserExtensionApiKey],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const workspaces = multiUserMode(response)
+          ? await Workspace.whereWithUser(user)
+          : await Workspace.where();
+
+        response.status(200).json({ workspaces });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ error: "Failed to fetch workspaces" });
+      }
+    }
+  );
+
+  app.post(
+    "/browser-extension/embed-content",
+    [validBrowserExtensionApiKey],
+    async (request, response) => {
+      try {
+        const { workspaceId, textContent, metadata } = reqBody(request);
+        const user = await userFromSession(request, response);
+        const workspace = multiUserMode(response)
+          ? await Workspace.getWithUser(user, { id: parseInt(workspaceId) })
+          : await Workspace.get({ id: parseInt(workspaceId) });
+
+        if (!workspace) {
+          response.status(404).json({ error: "Workspace not found" });
+          return;
+        }
+
+        const Collector = new CollectorApi();
+        const { success, reason, documents } = await Collector.processRawText(
+          textContent,
+          metadata
+        );
+
+        if (!success) {
+          response.status(500).json({ success: false, error: reason });
+          return;
+        }
+
+        const { failedToEmbed = [], errors = [] } = await Document.addDocuments(
+          workspace,
+          [documents[0].location],
+          user?.id
+        );
+
+        if (failedToEmbed.length > 0) {
+          response.status(500).json({ success: false, error: errors[0] });
+          return;
+        }
+
+        response.status(200).json({ success: true });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ error: "Failed to embed content" });
+      }
+    }
+  );
+
+  app.post(
+    "/browser-extension/upload-content",
+    [validBrowserExtensionApiKey],
+    async (request, response) => {
+      try {
+        const { textContent, metadata } = reqBody(request);
+        const Collector = new CollectorApi();
+        const { success, reason } = await Collector.processRawText(
+          textContent,
+          metadata
+        );
+
+        if (!success) {
+          response.status(500).json({ success: false, error: reason });
+          return;
+        }
+
+        response.status(200).json({ success: true });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ error: "Failed to embed content" });
+      }
+    }
+  );
+
+  // Internal endpoints for managing API keys
+  app.get(
+    "/browser-extension/api-keys",
+    [validatedRequest, flexUserRoleValid([ROLES.admin, ROLES.manager])],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const apiKeys = multiUserMode(response)
+          ? await BrowserExtensionApiKey.whereWithUser(user)
+          : await BrowserExtensionApiKey.where();
+
+        response.status(200).json({ success: true, apiKeys });
+      } catch (error) {
+        console.error(error);
+        response
+          .status(500)
+          .json({ success: false, error: "Failed to fetch API keys" });
+      }
+    }
+  );
+
+  app.post(
+    "/browser-extension/api-keys/new",
+    [validatedRequest, flexUserRoleValid([ROLES.admin, ROLES.manager])],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const { apiKey, error } = await BrowserExtensionApiKey.create(
+          user?.id || null
+        );
+        if (error) throw new Error(error);
+        response.status(200).json({
+          apiKey: apiKey.key,
+        });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ error: "Failed to create API key" });
+      }
+    }
+  );
+
+  app.delete(
+    "/browser-extension/api-keys/:id",
+    [validatedRequest, flexUserRoleValid([ROLES.admin, ROLES.manager])],
+    async (request, response) => {
+      try {
+        const { id } = request.params;
+        const user = await userFromSession(request, response);
+
+        if (multiUserMode(response) && user.role !== ROLES.admin) {
+          const apiKey = await BrowserExtensionApiKey.get({
+            id: parseInt(id),
+            user_id: user?.id,
+          });
+          if (!apiKey) {
+            return response.status(403).json({ error: "Unauthorized" });
+          }
+        }
+
+        const { success, error } = await BrowserExtensionApiKey.delete(id);
+        if (!success) throw new Error(error);
+        response.status(200).json({ success: true });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ error: "Failed to revoke API key" });
+      }
+    }
+  );
+}
+
+module.exports = { browserExtensionEndpoints };

package/server/endpoints/chat.js

@@ -0,0 +1,193 @@
+const { v4: uuidv4 } = require("uuid");
+const { reqBody, userFromSession, multiUserMode } = require("../utils/http");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const { streamChatWithWorkspace } = require("../utils/chats/stream");
+const {
+  ROLES,
+  flexUserRoleValid,
+} = require("../utils/middleware/multiUserProtected");
+const { EventLogs } = require("../models/eventLogs");
+const {
+  validWorkspaceAndThreadSlug,
+  validWorkspaceSlug,
+} = require("../utils/middleware/validWorkspace");
+const { writeResponseChunk } = require("../utils/helpers/chat/responses");
+const { WorkspaceThread } = require("../models/workspaceThread");
+const { User } = require("../models/user");
+const { getModelTag } = require("./utils");
+
+function chatEndpoints(app) {
+  if (!app) return;
+
+  app.post(
+    "/workspace/:slug/stream-chat",
+    [validatedRequest, flexUserRoleValid([ROLES.all]), validWorkspaceSlug],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const { message, attachments = [] } = reqBody(request);
+        const workspace = response.locals.workspace;
+
+        if (typeof message !== "string" || message.trim().length === 0) {
+          response.status(400).json({
+            id: uuidv4(),
+            type: "abort",
+            textResponse: null,
+            sources: [],
+            close: true,
+            error: "Message is empty.",
+          });
+          return;
+        }
+
+        response.setHeader("Cache-Control", "no-cache");
+        response.setHeader("Content-Type", "text/event-stream");
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Connection", "keep-alive");
+        response.flushHeaders();
+
+        if (multiUserMode(response) && !(await User.canSendChat(user))) {
+          writeResponseChunk(response, {
+            id: uuidv4(),
+            type: "abort",
+            textResponse: null,
+            sources: [],
+            close: true,
+            error: `You have met your maximum 24 hour chat quota of ${user.dailyMessageLimit} chats. Try again later.`,
+          });
+          return;
+        }
+
+        await streamChatWithWorkspace(
+          response,
+          workspace,
+          message,
+          workspace?.chatMode,
+          user,
+          null,
+          attachments
+        );
+
+        await EventLogs.logEvent(
+          "sent_chat",
+          {
+            workspaceName: workspace?.name,
+            chatModel: workspace?.chatModel || "System Default",
+          },
+          user?.id
+        );
+        response.end();
+      } catch (e) {
+        console.error(e);
+        writeResponseChunk(response, {
+          id: uuidv4(),
+          type: "abort",
+          textResponse: null,
+          sources: [],
+          close: true,
+          error: e.message,
+        });
+        response.end();
+      }
+    }
+  );
+
+  app.post(
+    "/workspace/:slug/thread/:threadSlug/stream-chat",
+    [
+      validatedRequest,
+      flexUserRoleValid([ROLES.all]),
+      validWorkspaceAndThreadSlug,
+    ],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const { message, attachments = [] } = reqBody(request);
+        const workspace = response.locals.workspace;
+        const thread = response.locals.thread;
+
+        if (typeof message !== "string" || message.trim().length === 0) {
+          response.status(400).json({
+            id: uuidv4(),
+            type: "abort",
+            textResponse: null,
+            sources: [],
+            close: true,
+            error: "Message is empty.",
+          });
+          return;
+        }
+
+        response.setHeader("Cache-Control", "no-cache");
+        response.setHeader("Content-Type", "text/event-stream");
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Connection", "keep-alive");
+        response.flushHeaders();
+
+        if (multiUserMode(response) && !(await User.canSendChat(user))) {
+          writeResponseChunk(response, {
+            id: uuidv4(),
+            type: "abort",
+            textResponse: null,
+            sources: [],
+            close: true,
+            error: `You have met your maximum 24 hour chat quota of ${user.dailyMessageLimit} chats. Try again later.`,
+          });
+          return;
+        }
+
+        await streamChatWithWorkspace(
+          response,
+          workspace,
+          message,
+          workspace?.chatMode,
+          user,
+          thread,
+          attachments
+        );
+
+        // If thread was renamed emit event to frontend via special `action` response.
+        await WorkspaceThread.autoRenameThread({
+          thread,
+          workspace,
+          user,
+          prompt: message,
+          onRename: (thread) => {
+            writeResponseChunk(response, {
+              action: "rename_thread",
+              thread: {
+                slug: thread.slug,
+                name: thread.name,
+              },
+            });
+          },
+        });
+
+
+        await EventLogs.logEvent(
+          "sent_chat",
+          {
+            workspaceName: workspace.name,
+            thread: thread.name,
+            chatModel: workspace?.chatModel || "System Default",
+          },
+          user?.id
+        );
+        response.end();
+      } catch (e) {
+        console.error(e);
+        writeResponseChunk(response, {
+          id: uuidv4(),
+          type: "abort",
+          textResponse: null,
+          sources: [],
+          close: true,
+          error: e.message,
+        });
+        response.end();
+      }
+    }
+  );
+}
+
+module.exports = { chatEndpoints };

package/server/endpoints/communityHub.js

@@ -0,0 +1,214 @@
+const { SystemSettings } = require("../models/systemSettings");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const { reqBody } = require("../utils/http");
+const { CommunityHub } = require("../models/communityHub");
+const {
+  communityHubDownloadsEnabled,
+  communityHubItem,
+} = require("../utils/middleware/communityHubDownloadsEnabled");
+const { EventLogs } = require("../models/eventLogs");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../utils/middleware/multiUserProtected");
+const { requireFeature } = require("../utils/middleware/requireFeature");
+
+function communityHubEndpoints(app) {
+  if (!app) return;
+
+  // Gate all community hub routes based on the active build profile
+  app.use("/community-hub", requireFeature("communityHub"));
+
+  app.get(
+    "/community-hub/settings",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_, response) => {
+      try {
+        const { connectionKey } = await SystemSettings.hubSettings();
+        response.status(200).json({ success: true, connectionKey });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ success: false, error: error.message });
+      }
+    }
+  );
+
+  app.post(
+    "/community-hub/settings",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const data = reqBody(request);
+        const result = await SystemSettings.updateSettings(data);
+        if (result.error) throw new Error(result.error);
+        response.status(200).json({ success: true, error: null });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ success: false, error: error.message });
+      }
+    }
+  );
+
+  app.get(
+    "/community-hub/explore",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_, response) => {
+      try {
+        const exploreItems = await CommunityHub.fetchExploreItems();
+        response.status(200).json({ success: true, result: exploreItems });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({
+          success: false,
+          result: null,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  app.post(
+    "/community-hub/item",
+    [validatedRequest, flexUserRoleValid([ROLES.admin]), communityHubItem],
+    async (_request, response) => {
+      try {
+        response.status(200).json({
+          success: true,
+          item: response.locals.bundleItem,
+          error: null,
+        });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({
+          success: false,
+          item: null,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  /**
+   * Apply an item to the AnythingLLM instance. Used for simple items like slash commands and system prompts.
+   */
+  app.post(
+    "/community-hub/apply",
+    [validatedRequest, flexUserRoleValid([ROLES.admin]), communityHubItem],
+    async (request, response) => {
+      try {
+        const { options = {} } = reqBody(request);
+        const item = response.locals.bundleItem;
+        const { error: applyError } = await CommunityHub.applyItem(item, {
+          ...options,
+          currentUser: response.locals?.user,
+        });
+        if (applyError) throw new Error(applyError);
+
+        await EventLogs.logEvent(
+          "community_hub_import",
+          {
+            itemId: response.locals.bundleItem.id,
+            itemType: response.locals.bundleItem.itemType,
+          },
+          response.locals?.user?.id
+        );
+
+        response.status(200).json({ success: true, error: null });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ success: false, error: error.message });
+      }
+    }
+  );
+
+  /**
+   * Import a bundle item to the AnythingLLM instance by downloading the zip file and importing it.
+   * or whatever the item type requires. This is not used if the item is a simple text responses like
+   * slash commands or system prompts.
+   */
+  app.post(
+    "/community-hub/import",
+    [
+      validatedRequest,
+      flexUserRoleValid([ROLES.admin]),
+      communityHubItem,
+      communityHubDownloadsEnabled,
+    ],
+    async (_, response) => {
+      try {
+        const { error: importError } = await CommunityHub.importBundleItem({
+          url: response.locals.bundleUrl,
+          item: response.locals.bundleItem,
+        });
+        if (importError) throw new Error(importError);
+
+        await EventLogs.logEvent(
+          "community_hub_import",
+          {
+            itemId: response.locals.bundleItem.id,
+            itemType: response.locals.bundleItem.itemType,
+          },
+          response.locals?.user?.id
+        );
+
+        response.status(200).json({ success: true, error: null });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  app.get(
+    "/community-hub/items",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_, response) => {
+      try {
+        const { connectionKey } = await SystemSettings.hubSettings();
+        const items = await CommunityHub.fetchUserItems(connectionKey);
+        response.status(200).json({ success: true, ...items });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ success: false, error: error.message });
+      }
+    }
+  );
+
+  app.post(
+    "/community-hub/:communityHubItemType/create",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { communityHubItemType } = request.params;
+        const { connectionKey } = await SystemSettings.hubSettings();
+        if (!connectionKey)
+          throw new Error("Community Hub connection key not found");
+
+        const data = reqBody(request);
+        const { success, error, itemId } = await CommunityHub.createStaticItem(
+          communityHubItemType,
+          data,
+          connectionKey
+        );
+        if (!success) throw new Error(error);
+
+        await EventLogs.logEvent(
+          "community_hub_publish",
+          { itemType: communityHubItemType },
+          response.locals?.user?.id
+        );
+        response
+          .status(200)
+          .json({ success: true, error: null, item: { id: itemId } });
+      } catch (error) {
+        console.error(error);
+        response.status(500).json({ success: false, error: error.message });
+      }
+    }
+  );
+}
+
+module.exports = { communityHubEndpoints };