totem-llm 0.1.0

package/server/endpoints/telegram.js

@@ -0,0 +1,333 @@
+const {
+  ExternalCommunicationConnector,
+} = require("../models/externalCommunicationConnector");
+const { TelegramBotService } = require("../utils/telegramBot");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const { isSingleUserMode } = require("../utils/middleware/multiUserProtected");
+const { reqBody } = require("../utils/http");
+const { EventLogs } = require("../models/eventLogs");
+const { Workspace } = require("../models/workspace");
+const { WorkspaceThread } = require("../models/workspaceThread");
+const { encryptToken } = require("../utils/telegramBot/utils");
+
+function telegramEndpoints(app) {
+  if (!app) return;
+
+  app.get(
+    "/telegram/config",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const connector = await ExternalCommunicationConnector.get("telegram");
+        if (!connector) {
+          return response.status(200).json({ config: null });
+        }
+
+        const service = new TelegramBotService();
+
+        // Resolve workspace, thread, and model from the first approved user's
+        // active state, falling back to the default workspace config.
+        const approvedUsers = connector.config.approved_users || [];
+        const activeUser = approvedUsers[0];
+        const workspaceSlug =
+          activeUser?.active_workspace ||
+          connector.config.default_workspace ||
+          null;
+        const threadSlug = activeUser?.active_thread || null;
+
+        let thread = null;
+        let workspace = await Workspace.get({ slug: workspaceSlug });
+        if (!workspace) {
+          const available = await Workspace.where({}, 1);
+          if (available.length) workspace = available[0];
+        }
+
+        if (!threadSlug) {
+          const availableThreads = await WorkspaceThread.where({
+            workspace_id: workspace.id,
+          });
+          if (availableThreads.length) thread = availableThreads[0];
+        }
+
+        return response.status(200).json({
+          config: {
+            active: connector.active,
+            connected: service.isRunning,
+            bot_username: connector.config.bot_username || null,
+            default_workspace: workspace?.name || workspaceSlug || "—",
+            active_thread_name: thread?.name || "Default",
+            chat_model: workspace?.chatModel || "System default",
+            voice_response_mode:
+              connector.config.voice_response_mode || "text_only",
+          },
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  /**
+   * Verify token, save config, and start the Telegram bot.
+   */
+  app.post(
+    "/telegram/connect",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { bot_token, default_workspace = null } = reqBody(request);
+        if (!bot_token) {
+          return response.status(400).json({
+            success: false,
+            error: "Bot token is required.",
+          });
+        }
+
+        // Verify the token with Telegram API
+        const verification = await TelegramBotService.verifyToken(
+          String(bot_token)
+        );
+        if (!verification.valid) {
+          return response.status(400).json({
+            success: false,
+            error: `Invalid bot token: ${verification.error}`,
+          });
+        }
+
+        let workspaceSlug = null;
+        if (default_workspace) workspaceSlug = String(default_workspace);
+        else {
+          const workspaces = await Workspace.where({}, 1);
+          if (workspaces.length) workspaceSlug = workspaces[0].slug;
+          else {
+            const { workspace } = await Workspace.new(
+              `${verification.username} Workspace`,
+              null,
+              { chatMode: "automatic" }
+            );
+            if (workspace) workspaceSlug = workspace.slug;
+          }
+        }
+
+        if (!workspaceSlug) {
+          return response.status(400).json({
+            success: false,
+            error: "No workspace found or could be created.",
+          });
+        }
+
+        // Preserve approved users when reconnecting with a new token
+        const existing = await ExternalCommunicationConnector.get("telegram");
+        const storedConfig = {
+          bot_username: verification.username,
+          default_workspace: workspaceSlug,
+          approved_users: existing?.config?.approved_users || [],
+          voice_response_mode:
+            existing?.config?.voice_response_mode || "text_only",
+        };
+
+        // Save config with encrypted token
+        const { error } = await ExternalCommunicationConnector.upsert(
+          "telegram",
+          {
+            ...storedConfig,
+            bot_token: encryptToken(String(bot_token)),
+            active: true,
+          }
+        );
+        if (error) return response.status(500).json({ success: false, error });
+
+        // Start the bot with the plaintext token
+        const service = new TelegramBotService();
+        await service.start({ ...storedConfig, bot_token: String(bot_token) });
+
+        await EventLogs.logEvent("telegram_bot_connected", {
+          bot_username: verification.username,
+        });
+        return response.status(200).json({
+          success: true,
+          bot_username: verification.username,
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/telegram/disconnect",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const service = new TelegramBotService();
+        await service.stop();
+        await ExternalCommunicationConnector.delete("telegram");
+        await EventLogs.logEvent("telegram_bot_disconnected");
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.get(
+    "/telegram/status",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const connector = await ExternalCommunicationConnector.get("telegram");
+        const service = new TelegramBotService();
+        return response.status(200).json({
+          active: connector?.active && service.isRunning,
+          bot_username: connector?.config?.bot_username || null,
+        });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.get(
+    "/telegram/pending-users",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const service = new TelegramBotService();
+        return response
+          .status(200)
+          .json({ users: service.pendingPairings || [] });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.get(
+    "/telegram/approved-users",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const connector = await ExternalCommunicationConnector.get("telegram");
+        const approved = connector?.config?.approved_users || [];
+        return response.status(200).json({ users: approved });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/telegram/approve-user",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { chatId } = reqBody(request);
+        if (!chatId)
+          return response
+            .status(400)
+            .json({ success: false, error: "chatId is required." });
+
+        const service = new TelegramBotService();
+        await service.approvePendingUser(chatId);
+        await EventLogs.logEvent("telegram_user_approved", { chatId });
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/telegram/deny-user",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { chatId } = reqBody(request);
+        if (!chatId)
+          return response
+            .status(400)
+            .json({ success: false, error: "chatId is required." });
+
+        const service = new TelegramBotService();
+        await service.denyPendingUser(chatId);
+        await EventLogs.logEvent("telegram_user_denied", { chatId });
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/telegram/revoke-user",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { chatId } = reqBody(request);
+        if (!chatId)
+          return response
+            .status(400)
+            .json({ success: false, error: "chatId is required." });
+
+        const service = new TelegramBotService();
+        await service.revokeExistingUser(chatId);
+        await EventLogs.logEvent("telegram_user_revoked", { chatId });
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/telegram/update-config",
+    [validatedRequest, isSingleUserMode],
+    async (request, response) => {
+      try {
+        const { voice_response_mode } = reqBody(request);
+        const updates = {};
+
+        if (
+          voice_response_mode &&
+          ["text_only", "mirror", "always_voice"].includes(voice_response_mode)
+        ) {
+          updates.voice_response_mode = voice_response_mode;
+        }
+
+        if (Object.keys(updates).length === 0) {
+          return response
+            .status(400)
+            .json({ success: false, error: "No valid updates provided." });
+        }
+
+        const { error } = await ExternalCommunicationConnector.updateConfig(
+          "telegram",
+          updates
+        );
+        if (error) {
+          return response.status(500).json({ success: false, error });
+        }
+
+        // Update the running bot's config so changes take effect immediately
+        const service = new TelegramBotService();
+        if (service.isRunning) service.updateConfig(updates);
+
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e.message, e);
+        response.sendStatus(500);
+      }
+    }
+  );
+}
+
+module.exports = { telegramEndpoints };

package/server/endpoints/utils/dockerModelRunnerUtils.js

@@ -0,0 +1,94 @@
+const { validatedRequest } = require("../../utils/middleware/validatedRequest");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../../utils/middleware/multiUserProtected");
+const { reqBody } = require("../../utils/http");
+const { safeJsonParse, decodeHtmlEntities } = require("../../utils/http");
+
+function dockerModelRunnerUtilsEndpoints(app) {
+  if (!app) return;
+  const {
+    parseDockerModelRunnerEndpoint,
+  } = require("../../utils/AiProviders/dockerModelRunner");
+
+  app.post(
+    "/utils/dmr/download-model",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { modelId, basePath = "" } = reqBody(request);
+        const dmrUrl = new URL(
+          parseDockerModelRunnerEndpoint(
+            basePath ?? process.env.DOCKER_MODEL_RUNNER_BASE_PATH,
+            "dmr"
+          )
+        );
+        dmrUrl.pathname = "/models/create";
+        response.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+        });
+
+        const dmrResponse = await fetch(dmrUrl.toString(), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ from: String(modelId) }),
+        });
+        if (!dmrResponse.ok)
+          throw new Error(
+            dmrResponse.statusText ||
+              "An error occurred while downloading the model"
+          );
+        const reader = dmrResponse.body.getReader();
+        let done = false;
+        while (!done) {
+          const { value, done: readerDone } = await reader.read();
+          if (readerDone) done = true;
+
+          const chunk = new TextDecoder("utf-8").decode(value);
+          const lines = chunk.split("\n");
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            const decodedLine = decodeHtmlEntities(line);
+            const data = safeJsonParse(decodedLine);
+            if (!data) continue;
+
+            if (data.type === "error") {
+              throw new Error(
+                data.message || "An error occurred while downloading the model"
+              );
+            } else if (data.type === "success") {
+              response.write(
+                `data: ${JSON.stringify({ type: "success", percentage: 100, message: "Model downloaded successfully" })}\n\n`
+              );
+              done = true;
+            } else if (data.type === "progress") {
+              const percentage =
+                data.total > 0
+                  ? Math.round((data.pulled / data.total) * 100)
+                  : 0;
+              response.write(
+                `data: ${JSON.stringify({ type: "progress", percentage, message: data.message })}\n\n`
+              );
+            }
+          }
+        }
+      } catch (e) {
+        console.error(e);
+        response.write(
+          `data: ${JSON.stringify({ type: "error", message: e.message })}\n\n`
+        );
+      } finally {
+        response.end();
+      }
+    }
+  );
+}
+
+module.exports = {
+  dockerModelRunnerUtilsEndpoints,
+};

package/server/endpoints/utils/googleAgentSkillEndpoints.js

@@ -0,0 +1,70 @@
+const {
+  isSingleUserMode,
+} = require("../../utils/middleware/multiUserProtected");
+const { validatedRequest } = require("../../utils/middleware/validatedRequest");
+const { GmailBridge } = require("../../utils/agents/aibitat/plugins/gmail/lib");
+const {
+  GoogleCalendarBridge,
+} = require("../../utils/agents/aibitat/plugins/google-calendar/lib");
+
+function googleAgentSkillEndpoints(app) {
+  if (!app) return;
+
+  app.get(
+    "/admin/agent-skills/gmail/status",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const config = await GmailBridge.getConfig();
+
+        const hasDeploymentId = !!config.deploymentId;
+        const hasApiKey = !!config.apiKey;
+        const isConfigured = hasDeploymentId && hasApiKey;
+
+        const safeConfig = {
+          deploymentId: config.deploymentId || "",
+          apiKey: hasApiKey ? "********" : "",
+        };
+
+        return response.status(200).json({
+          success: true,
+          isConfigured,
+          config: safeConfig,
+        });
+      } catch (e) {
+        console.error("Gmail status error:", e);
+        response.status(500).json({ success: false, error: e.message });
+      }
+    }
+  );
+
+  app.get(
+    "/admin/agent-skills/google-calendar/status",
+    [validatedRequest, isSingleUserMode],
+    async (_request, response) => {
+      try {
+        const config = await GoogleCalendarBridge.getConfig();
+
+        const hasDeploymentId = !!config.deploymentId;
+        const hasApiKey = !!config.apiKey;
+        const isConfigured = hasDeploymentId && hasApiKey;
+
+        const safeConfig = {
+          deploymentId: config.deploymentId || "",
+          apiKey: hasApiKey ? "********" : "",
+        };
+
+        return response.status(200).json({
+          success: true,
+          isConfigured,
+          config: safeConfig,
+        });
+      } catch (e) {
+        console.error("Google Calendar status error:", e);
+        response.status(500).json({ success: false, error: e.message });
+      }
+    }
+  );
+}
+
+module.exports = { googleAgentSkillEndpoints };

package/server/endpoints/utils/lemonadeUtilsEndpoints.js

@@ -0,0 +1,170 @@
+const { validatedRequest } = require("../../utils/middleware/validatedRequest");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../../utils/middleware/multiUserProtected");
+const { reqBody } = require("../../utils/http");
+const { safeJsonParse, decodeHtmlEntities } = require("../../utils/http");
+const {
+  parseLemonadeServerEndpoint,
+} = require("../../utils/AiProviders/lemonade");
+
+function lemonadeUtilsEndpoints(app) {
+  if (!app) return;
+
+  app.post(
+    "/utils/lemonade/download-model",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { modelId, basePath = "" } = reqBody(request);
+        const lemonadeUrl = new URL(
+          parseLemonadeServerEndpoint(
+            basePath ?? process.env.LEMONADE_LLM_BASE_PATH,
+            "base"
+          )
+        );
+        lemonadeUrl.pathname += "api/v1/pull";
+        response.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+        });
+
+        const lemonadeResponse = await fetch(lemonadeUrl.toString(), {
+          method: "POST",
+          headers: {
+            ...(!!process.env.LEMONADE_LLM_API_KEY
+              ? { Authorization: `Bearer ${process.env.LEMONADE_LLM_API_KEY}` }
+              : {}),
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            model_name: String(modelId),
+            stream: true,
+          }),
+        });
+        if (!lemonadeResponse.ok)
+          throw new Error(
+            lemonadeResponse.statusText ||
+              "An error occurred while downloading the model"
+          );
+        const reader = lemonadeResponse.body.getReader();
+        let done = false;
+        let currentEvent = null;
+
+        while (!done) {
+          const { value, done: readerDone } = await reader.read();
+          if (readerDone) done = true;
+
+          const chunk = new TextDecoder("utf-8").decode(value);
+          const lines = chunk.split("\n");
+          for (const line of lines) {
+            if (!line.trim()) continue;
+
+            if (line.startsWith("event:")) {
+              currentEvent = line.replace("event:", "").trim();
+              continue;
+            }
+
+            if (line.startsWith("data:")) {
+              const jsonStr = line.replace("data:", "").trim();
+              const decodedLine = decodeHtmlEntities(jsonStr);
+              const data = safeJsonParse(decodedLine);
+              if (!data) continue;
+
+              if (currentEvent === "error") {
+                throw new Error(
+                  data.message ||
+                    "An error occurred while downloading the model"
+                );
+              } else if (currentEvent === "complete") {
+                response.write(
+                  `data: ${JSON.stringify({ type: "success", percentage: 100, message: "Model downloaded successfully" })}\n\n`
+                );
+                done = true;
+              } else if (currentEvent === "progress") {
+                const percentage = data.percent ?? 0;
+                const message = data.file
+                  ? `Downloading ${data.file}`
+                  : "Downloading model...";
+                response.write(
+                  `data: ${JSON.stringify({ type: "progress", percentage, message })}\n\n`
+                );
+              }
+
+              currentEvent = null;
+            }
+          }
+        }
+      } catch (e) {
+        console.error(e);
+        response.write(
+          `data: ${JSON.stringify({ type: "error", message: e.message })}\n\n`
+        );
+      } finally {
+        response.end();
+      }
+    }
+  );
+
+  app.post(
+    "/utils/lemonade/delete-model",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { modelId, basePath = "" } = reqBody(request);
+        if (!modelId) {
+          return response.status(400).json({
+            success: false,
+            error: "modelId is required",
+          });
+        }
+
+        const lemonadeUrl = new URL(
+          parseLemonadeServerEndpoint(
+            basePath ?? process.env.LEMONADE_LLM_BASE_PATH,
+            "base"
+          )
+        );
+        lemonadeUrl.pathname += "api/v1/delete";
+
+        const lemonadeResponse = await fetch(lemonadeUrl.toString(), {
+          method: "POST",
+          headers: {
+            ...(!!process.env.LEMONADE_LLM_API_KEY
+              ? { Authorization: `Bearer ${process.env.LEMONADE_LLM_API_KEY}` }
+              : {}),
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            model_name: String(modelId),
+          }),
+        });
+
+        const data = await lemonadeResponse.json();
+        if (!lemonadeResponse.ok || data.status === "error") {
+          return response.status(lemonadeResponse.status || 500).json({
+            success: false,
+            error: data.message || "An error occurred while deleting the model",
+          });
+        }
+
+        return response.status(200).json({
+          success: true,
+          message: data.message || `Deleted model: ${modelId}`,
+        });
+      } catch (e) {
+        console.error(e);
+        return response.status(500).json({
+          success: false,
+          error: e.message || "An error occurred while deleting the model",
+        });
+      }
+    }
+  );
+}
+
+module.exports = {
+  lemonadeUtilsEndpoints,
+};