totem-llm 0.1.0

package/server/utils/boot/MetaGenerator.js

@@ -0,0 +1,376 @@
+/**
+ * @typedef MetaTagDefinition
+ * @property {('link'|'meta')} tag - the type of meta tag element
+ * @property {{string:string}|null} props - the inner key/values of a meta tag
+ * @property {string|null} content - Text content to be injected between tags. If null self-closing.
+ */
+
+/**
+ * This class serves the default index.html page that is not present when built in production.
+ * and therefore this class should not be called when in development mode since it is unused.
+ * All this class does is basically emulate SSR for the meta-tag generation of the root index page.
+ * Since we are an SPA, we can just render the primary page and the known entrypoints for the index.{js,css}
+ * we can always start at the right place and dynamically load in lazy-loaded as we typically normally would
+ * and we dont have any of the overhead that would normally come with having the rewrite the whole app in next or something.
+ * Lastly, this class is singleton, so once instantiate the same reference is shared for as long as the server is alive.
+ * the main function is `.generate()` which will return the index HTML. These settings are stored in the #customConfig
+ * static property and will not be reloaded until the page is loaded AND #customConfig is explicitly null. So anytime a setting
+ * for meta-props is updated you should get this singleton class and call `.clearConfig` so the next page load will show the new props.
+ */
+class MetaGenerator {
+  name = "MetaGenerator";
+
+  /** @type {MetaGenerator|null} */
+  static _instance = null;
+
+  /** @type {MetaTagDefinition[]|null} */
+  #customConfig = null;
+
+  #defaultManifest = {
+    name: "Totem LLM",
+    short_name: "Totem LLM",
+    display: "standalone",
+    orientation: "portrait",
+    start_url: "/",
+    icons: [
+      {
+        src: "/favicon.png",
+        sizes: "any",
+      },
+    ],
+  };
+
+  constructor() {
+    if (MetaGenerator._instance) return MetaGenerator._instance;
+    MetaGenerator._instance = this;
+  }
+
+  #log(text, ...args) {
+    console.log(`\x1b[36m[${this.name}]\x1b[0m ${text}`, ...args);
+  }
+
+  #defaultMeta() {
+    return [
+      {
+        tag: "link",
+        props: { type: "image/svg+xml", href: "/favicon.png" },
+        content: null,
+      },
+      {
+        tag: "title",
+        props: null,
+        content: "Totem LLM | Your private AI",
+      },
+
+      {
+        tag: "meta",
+        props: {
+          name: "title",
+          content: "Totem LLM | Your private AI",
+        },
+      },
+      {
+        tag: "meta",
+        props: {
+          description: "title",
+          content: "Totem LLM | Your private AI",
+        },
+      },
+
+      // <!-- Facebook -->
+      { tag: "meta", props: { property: "og:type", content: "website" } },
+      {
+        tag: "meta",
+        props: { property: "og:url", content: "https://github.com/fred-terzi/totem-llm" },
+      },
+      {
+        tag: "meta",
+        props: {
+          property: "og:title",
+          content: "Totem LLM | Your private AI",
+        },
+      },
+      {
+        tag: "meta",
+        props: {
+          property: "og:description",
+          content: "Totem LLM | Your private AI",
+        },
+      },
+      {
+        tag: "meta",
+        props: {
+          property: "og:image",
+          content:
+            "https://raw.githubusercontent.com/fred-terzi/totem-llm/main/images/totem_logo.png",
+        },
+      },
+
+      // <!-- Twitter -->
+      {
+        tag: "meta",
+        props: { property: "twitter:card", content: "summary_large_image" },
+      },
+      {
+        tag: "meta",
+        props: { property: "twitter:url", content: "https://github.com/fred-terzi/totem-llm" },
+      },
+      {
+        tag: "meta",
+        props: {
+          property: "twitter:title",
+          content: "Totem LLM | Your private AI",
+        },
+      },
+      {
+        tag: "meta",
+        props: {
+          property: "twitter:description",
+          content: "Totem LLM | Your private AI",
+        },
+      },
+      {
+        tag: "meta",
+        props: {
+          property: "twitter:image",
+          content:
+            "https://raw.githubusercontent.com/fred-terzi/totem-llm/main/images/totem_logo.png",
+        },
+      },
+
+      { tag: "link", props: { rel: "icon", href: "/favicon.png" } },
+      { tag: "link", props: { rel: "apple-touch-icon", href: "/favicon.png" } },
+
+      // PWA specific tags
+      {
+        tag: "meta",
+        props: { name: "mobile-web-app-capable", content: "yes" },
+      },
+      {
+        tag: "meta",
+        props: { name: "apple-mobile-web-app-capable", content: "yes" },
+      },
+      {
+        tag: "meta",
+        props: {
+          name: "apple-mobile-web-app-status-bar-style",
+          content: "black-translucent",
+        },
+      },
+      { tag: "link", props: { rel: "manifest", href: "/manifest.json" } },
+    ];
+  }
+
+  /**
+   * Assembles Meta tags as one large string
+   * @param {MetaTagDefinition[]} tagArray
+   * @returns {string}
+   */
+  #assembleMeta() {
+    const output = [];
+    for (const tag of this.#customConfig) {
+      let htmlString;
+      htmlString = `<${tag.tag} `;
+
+      if (tag.props !== null) {
+        for (const [key, value] of Object.entries(tag.props))
+          htmlString += `${key}="${value}" `;
+      }
+
+      if (tag.content) {
+        htmlString += `>${tag.content}</${tag.tag}>`;
+      } else {
+        htmlString += `>`;
+      }
+      output.push(htmlString);
+    }
+    return output.join("\n");
+  }
+
+  #validUrl(faviconUrl = null) {
+    if (faviconUrl === null) return "/favicon.png";
+    try {
+      const url = new URL(faviconUrl);
+      return url.toString();
+    } catch {
+      return "/favicon.png";
+    }
+  }
+
+  async #fetchConfg() {
+    this.#log(`fetching custom meta tag settings...`);
+    const { SystemSettings } = require("../../models/systemSettings");
+    const customTitle = await SystemSettings.getValueOrFallback(
+      { label: "meta_page_title" },
+      null
+    );
+    const faviconURL = await SystemSettings.getValueOrFallback(
+      { label: "meta_page_favicon" },
+      null
+    );
+
+    // If nothing defined - assume defaults.
+    if (customTitle === null && faviconURL === null) {
+      this.#customConfig = this.#defaultMeta();
+    } else {
+      // When custom settings exist, include all default meta tags but override specific ones
+      this.#customConfig = this.#defaultMeta().map((tag) => {
+        // Override favicon link
+        if (tag.tag === "link" && tag.props?.rel === "icon") {
+          return {
+            tag: "link",
+            props: { rel: "icon", href: this.#validUrl(faviconURL) },
+          };
+        }
+        // Override page title
+        if (tag.tag === "title") {
+          return {
+            tag: "title",
+            props: null,
+            content:
+              customTitle ??
+              "Totem LLM | Your private AI",
+          };
+        }
+        // Override meta title
+        if (tag.tag === "meta" && tag.props?.name === "title") {
+          return {
+            tag: "meta",
+            props: {
+              name: "title",
+              content:
+                customTitle ??
+                "Totem LLM | Your private AI",
+            },
+          };
+        }
+        // Override og:title
+        if (tag.tag === "meta" && tag.props?.property === "og:title") {
+          return {
+            tag: "meta",
+            props: {
+              property: "og:title",
+              content:
+                customTitle ??
+                "Totem LLM | Your private AI",
+            },
+          };
+        }
+        // Override twitter:title
+        if (tag.tag === "meta" && tag.props?.property === "twitter:title") {
+          return {
+            tag: "meta",
+            props: {
+              property: "twitter:title",
+              content:
+                customTitle ??
+                "Totem LLM | Your private AI",
+            },
+          };
+        }
+        // Override apple-touch-icon if custom favicon is set
+        if (
+          tag.tag === "link" &&
+          tag.props?.rel === "apple-touch-icon" &&
+          faviconURL
+        ) {
+          return {
+            tag: "link",
+            props: {
+              rel: "apple-touch-icon",
+              href: this.#validUrl(faviconURL),
+            },
+          };
+        }
+        // Return original tag for everything else (including PWA tags)
+        return tag;
+      });
+    }
+
+    return this.#customConfig;
+  }
+
+  /**
+   * Clears the current config so it can be refetched on the server for next render.
+   */
+  clearConfig() {
+    this.#customConfig = null;
+  }
+
+  /**
+   *
+   * @param {import('express').Response} response
+   * @param {number} code
+   */
+  async generate(response, code = 200) {
+    if (this.#customConfig === null) await this.#fetchConfg();
+    response.status(code).send(`
+       <!DOCTYPE html>
+        <html lang="en">
+          <head>
+            <meta charset="UTF-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+            ${this.#assembleMeta()}
+            <script type="module" crossorigin src="/index.js"></script>
+            <link rel="stylesheet" href="/index.css">
+          </head>
+          <body>
+            <div id="root" class="h-screen"></div>
+          </body>
+        </html>`);
+  }
+
+  /**
+   * Generates the manifest.json file for the PWA application on the fly.
+   * @param {import('express').Response} response
+   * @param {number} code
+   */
+  async generateManifest(response) {
+    try {
+      const { SystemSettings } = require("../../models/systemSettings");
+      const manifestName = await SystemSettings.getValueOrFallback(
+        { label: "meta_page_title" },
+        "Totem LLM"
+      );
+      const faviconURL = await SystemSettings.getValueOrFallback(
+        { label: "meta_page_favicon" },
+        null
+      );
+
+      let iconUrl = "/favicon.png";
+      if (faviconURL) {
+        try {
+          new URL(faviconURL);
+          iconUrl = faviconURL;
+        } catch {
+          iconUrl = "/favicon.png";
+        }
+      }
+
+      const manifest = {
+        name: manifestName,
+        short_name: manifestName,
+        display: "standalone",
+        orientation: "portrait",
+        start_url: "/",
+        icons: [
+          {
+            src: iconUrl,
+            sizes: "any",
+          },
+        ],
+      };
+
+      response.type("application/json").status(200).send(manifest).end();
+    } catch (error) {
+      this.#log(`error generating manifest: ${error.message}`, error);
+      response
+        .type("application/json")
+        .status(200)
+        .send(this.#defaultManifest)
+        .end();
+    }
+  }
+}
+
+module.exports.MetaGenerator = MetaGenerator;

package/server/utils/boot/eagerLoadContextWindows.js

@@ -0,0 +1,40 @@
+/**
+ * Eagerly load the context windows for the current provider.
+ * This is done to ensure that the context windows are pre-cached when the server boots.
+ *
+ * This prevents us from having misreporting of the context window before a chat is ever sent.
+ * eg: when viewing the attachments in the workspace - the context window would be misreported if a chat
+ * has not been sent yet.
+ */
+async function eagerLoadContextWindows() {
+  const currentProvider = process.env.LLM_PROVIDER;
+
+  const log = (provider) => {
+    console.log(`⚡\x1b[32mPre-cached context windows for ${provider}\x1b[0m`);
+  };
+
+  switch (currentProvider) {
+    case "lmstudio":
+      const { LMStudioLLM } = require("../AiProviders/lmStudio");
+      await LMStudioLLM.cacheContextWindows(true);
+      log("LMStudio");
+      break;
+    case "ollama":
+      const { OllamaAILLM } = require("../AiProviders/ollama");
+      await OllamaAILLM.cacheContextWindows(true);
+      log("Ollama");
+      break;
+    case "foundry":
+      const { FoundryLLM } = require("../AiProviders/foundry");
+      await FoundryLLM.cacheContextWindows(true);
+      log("Foundry");
+      break;
+    case "cerebras":
+      const { CerebrasLLM } = require("../AiProviders/cerebras");
+      await CerebrasLLM.cacheContextWindows(true);
+      log("Cerebras");
+      break;
+  }
+}
+
+module.exports = eagerLoadContextWindows;

package/server/utils/boot/index.js

@@ -0,0 +1,90 @@
+const { BackgroundService } = require("../BackgroundWorkers");
+const { EncryptionManager } = require("../EncryptionManager");
+const { CommunicationKey } = require("../comKey");
+const eagerLoadContextWindows = require("./eagerLoadContextWindows");
+const markOnboarded = require("./markOnboarded");
+const { PushNotifications } = require("../PushNotifications");
+const { TelegramBotService } = require("../telegramBot");
+
+// Testing SSL? You can make a self signed certificate and point the ENVs to that location
+// make a directory in server called 'sslcert' - cd into it
+// - openssl genrsa -aes256 -passout pass:gsahdg -out server.pass.key 4096
+// - openssl rsa -passin pass:gsahdg -in server.pass.key -out server.key
+// - rm server.pass.key
+// - openssl req -new -key server.key -out server.csr
+// Update .env keys with the correct values and boot. These are temporary and not real SSL certs - only use for local.
+// Test with https://localhost:3001/api/ping
+// build and copy frontend to server/public with correct API_BASE and start server in prod model and all should be ok
+function bootSSL(app, port = 3001) {
+  try {
+    console.log(
+      `\x1b[33m[SSL BOOT ENABLED]\x1b[0m Loading the certificate and key for HTTPS mode...`
+    );
+    const fs = require("fs");
+    const https = require("https");
+    const privateKey = fs.readFileSync(process.env.HTTPS_KEY_PATH);
+    const certificate = fs.readFileSync(process.env.HTTPS_CERT_PATH);
+    const credentials = { key: privateKey, cert: certificate };
+    const server = https.createServer(credentials, app);
+
+    server
+      .listen(port, async () => {
+        await markOnboarded();
+        new CommunicationKey(true);
+        new EncryptionManager();
+        new BackgroundService().boot();
+        await eagerLoadContextWindows();
+        await PushNotifications.setupPushNotificationService();
+        await TelegramBotService.bootIfActive();
+        console.log(`Primary server in HTTPS mode listening on port ${port}`);
+      })
+      .on("error", catchSigTerms);
+
+    require("@mintplex-labs/express-ws").default(app, server);
+    return { app, server };
+  } catch (e) {
+    console.error(
+      `\x1b[31m[SSL BOOT FAILED]\x1b[0m ${e.message} - falling back to HTTP boot.`,
+      {
+        ENABLE_HTTPS: process.env.ENABLE_HTTPS,
+        HTTPS_KEY_PATH: process.env.HTTPS_KEY_PATH,
+        HTTPS_CERT_PATH: process.env.HTTPS_CERT_PATH,
+        stacktrace: e.stack,
+      }
+    );
+    return bootHTTP(app, port);
+  }
+}
+
+function bootHTTP(app, port = 3001) {
+  if (!app) throw new Error('No "app" defined - crashing!');
+
+  app
+    .listen(port, async () => {
+      await markOnboarded();
+      new CommunicationKey(true);
+      new EncryptionManager();
+      new BackgroundService().boot();
+      await eagerLoadContextWindows();
+      await PushNotifications.setupPushNotificationService();
+      await TelegramBotService.bootIfActive();
+      console.log(`Primary server in HTTP mode listening on port ${port}`);
+    })
+    .on("error", catchSigTerms);
+
+  return { app, server: null };
+}
+
+function catchSigTerms() {
+  process.once("SIGUSR2", function () {
+    process.kill(process.pid, "SIGUSR2");
+  });
+  process.on("SIGINT", function () {
+    process.kill(process.pid, "SIGINT");
+  });
+}
+
+module.exports = {
+  bootHTTP,
+  bootSSL,
+};

package/server/utils/boot/markOnboarded.js

@@ -0,0 +1,52 @@
+const { SystemSettings } = require("../../models/systemSettings");
+
+/**
+ * Mark the onboarding as completed for legacy users prior to this change where onboarding is now a flag in the DB.
+ * This is a legacy patch to ensure that existing users are not redirected to the onboarding page who have been using the app for a while.
+ */
+async function markOnboarded() {
+  try {
+    const onboardingStatus = await SystemSettings.isOnboardingComplete();
+    if (onboardingStatus === true) return;
+
+    // Check if the server is already onboarded by the old way of checking if the server in any way has been setup.
+    // If it is, then we can mark the onboarding as complete in the DB to persist this
+    const alreadyOnboarded = await isLegacyOnboarded();
+    if (alreadyOnboarded === true) {
+      console.log(
+        "\x1b[33m[ONBOARDING PATCH]\x1b[0m Legacy instance is already onboarded, marking onboarding as complete. You will not see this message again."
+      );
+      await SystemSettings.markOnboardingComplete();
+      return true;
+    }
+    return false;
+  } catch (e) {
+    console.error(
+      "\x1b[31m[ONBOARDING PATCH]\x1b[0m Error marking onboarding as complete",
+      e.message,
+      e
+    );
+    return false;
+  }
+}
+
+/**
+ * Check if the server is already onboarded by the old way of checking if the server in any way has been setup.
+ * @returns {Promise<boolean>}
+ */
+async function isLegacyOnboarded() {
+  // LLM Provider is set, so we can assume onboarding is complete since this is default null in SystemSettings.js
+  if (!!process.env.LLM_PROVIDER) return true;
+
+  // Vector DB is set, so we can assume onboarding is complete since this is default null in SystemSettings.js (default is lancedb in frontend)
+  if (!!process.env.VECTOR_DB) return true;
+
+  // Check if the AUTH_TOKEN/JWT_SECRET is set, so we can assume onboarding is complete since this is default null in SystemSettings.js
+  if (!!process.env.AUTH_TOKEN || !!process.env.JWT_SECRET) return true;
+
+  // Check multi-user mode is enabled, if it is, then they are already using the app.
+  if ((await SystemSettings.isMultiUserMode()) === true) return true;
+  return false;
+}
+
+module.exports = markOnboarded;

package/server/utils/chats/agents.js

@@ -0,0 +1,111 @@
+const pluralize = require("pluralize");
+const {
+  WorkspaceAgentInvocation,
+} = require("../../models/workspaceAgentInvocation");
+const { writeResponseChunk } = require("../helpers/chat/responses");
+const { Workspace } = require("../../models/workspace");
+
+/**
+ * In-memory cache for attachments associated with agent invocations.
+ * Attachments are stored here when grepAgents creates an invocation,
+ * then retrieved by AgentHandler when the websocket connects.
+ * @type {Map<string, Array>}
+ */
+const invocationAttachmentsCache = new Map();
+
+/**
+ * Store attachments for an invocation UUID
+ * @param {string} uuid - The invocation UUID
+ * @param {Array} attachments - The attachments array
+ */
+function cacheInvocationAttachments(uuid, attachments = []) {
+  if (attachments.length > 0) {
+    invocationAttachmentsCache.set(uuid, attachments);
+  }
+}
+
+/**
+ * Retrieve and remove attachments for an invocation UUID
+ * @param {string} uuid - The invocation UUID
+ * @returns {Array} The attachments array (empty if none cached)
+ */
+function getAndClearInvocationAttachments(uuid) {
+  const attachments = invocationAttachmentsCache.get(uuid) || [];
+  invocationAttachmentsCache.delete(uuid);
+  return attachments;
+}
+
+async function grepAgents({
+  uuid,
+  response,
+  message,
+  workspace,
+  user = null,
+  thread = null,
+  attachments = [],
+}) {
+  let nativeToolingEnabled = false;
+
+  // If the workspace is in automatic mode, check if the workspace supports native tooling
+  // to determine if the agent flow should be used or not.
+  if (workspace?.chatMode === "automatic")
+    nativeToolingEnabled = await Workspace.supportsNativeToolCalling(workspace);
+
+  const agentHandles = WorkspaceAgentInvocation.parseAgents(message);
+  if (agentHandles.length > 0 || nativeToolingEnabled) {
+    const { invocation: newInvocation } = await WorkspaceAgentInvocation.new({
+      prompt: message,
+      workspace: workspace,
+      user: user,
+      thread: thread,
+    });
+
+    if (!newInvocation) {
+      writeResponseChunk(response, {
+        id: uuid,
+        type: "statusResponse",
+        textResponse: `${pluralize(
+          "Agent",
+          agentHandles.length
+        )} ${agentHandles.join(
+          ", "
+        )} could not be called. Chat will be handled as default chat.`,
+        sources: [],
+        close: true,
+        animate: false,
+        error: null,
+      });
+      return;
+    }
+
+    // Cache attachments for the websocket handler to retrieve later
+    cacheInvocationAttachments(newInvocation.uuid, attachments);
+
+    writeResponseChunk(response, {
+      id: uuid,
+      type: "agentInitWebsocketConnection",
+      textResponse: null,
+      sources: [],
+      close: false,
+      error: null,
+      websocketUUID: newInvocation.uuid,
+    });
+
+    // Close HTTP stream-able chunk response method because we will swap to agents now.
+    writeResponseChunk(response, {
+      id: uuid,
+      type: "statusResponse",
+      textResponse:
+        "@agent: Swapping over to agent chat. Type /exit to exit agent execution loop early.",
+      sources: [],
+      close: true,
+      error: null,
+      animate: true,
+    });
+    return true;
+  }
+
+  return false;
+}
+
+module.exports = { grepAgents, getAndClearInvocationAttachments };