totem-llm 0.1.0

package/server/utils/telegramBot/utils/commands/handlers/showWorkspaceMenu.js

@@ -0,0 +1,84 @@
+const { Workspace } = require("../../../../../models/workspace");
+const WORKSPACES_PER_PAGE = 8;
+
+/**
+ * Show the workspace selection inline keyboard with pagination.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ * @param {number} page - Current page (0-indexed)
+ * @param {number|null} messageId - If provided, edits existing message instead of sending new one
+ */
+async function showWorkspaceMenu(ctx, chatId, page = 0, messageId = null) {
+  const pageNum = typeof page === "number" && !isNaN(page) ? page : 0;
+  const workspaces = await Workspace.where({});
+  if (!workspaces.length) {
+    await ctx.bot.sendMessage(
+      chatId,
+      "No workspaces found. Create one to get started!",
+      {
+        reply_markup: {
+          inline_keyboard: [
+            [{ text: "➕ Create Workspace", callback_data: "ws-create" }],
+          ],
+        },
+      }
+    );
+    return;
+  }
+
+  const state = ctx.getState(chatId);
+  const sortedWorkspaces = [...workspaces].sort((a, b) => {
+    const aIsActive = a.slug === state.workspaceSlug;
+    const bIsActive = b.slug === state.workspaceSlug;
+    if (aIsActive && !bIsActive) return -1;
+    if (!aIsActive && bIsActive) return 1;
+    return 0;
+  });
+
+  const totalPages = Math.ceil(sortedWorkspaces.length / WORKSPACES_PER_PAGE);
+  const safePage = Math.max(0, Math.min(pageNum, totalPages - 1));
+  const startIdx = safePage * WORKSPACES_PER_PAGE;
+  const pageWorkspaces = sortedWorkspaces.slice(
+    startIdx,
+    startIdx + WORKSPACES_PER_PAGE
+  );
+
+  const buttons = pageWorkspaces.map((ws) => {
+    const isCurrent = ws.slug === state.workspaceSlug;
+    return [
+      {
+        text: isCurrent ? `🟢 ${ws.name} (active)` : ws.name,
+        callback_data: `ws:${ws.id}`,
+      },
+    ];
+  });
+
+  const navRow = [];
+  if (safePage > 0) {
+    navRow.push({ text: "← Prev", callback_data: `wspg:${safePage - 1}` });
+  }
+  if (safePage < totalPages - 1) {
+    navRow.push({ text: "Next →", callback_data: `wspg:${safePage + 1}` });
+  }
+  if (navRow.length) buttons.push(navRow);
+
+  const text =
+    totalPages > 1
+      ? `Select a workspace (${safePage + 1}/${totalPages}, ${sortedWorkspaces.length} total):`
+      : "Select a workspace:";
+  const opts = {
+    reply_markup: { inline_keyboard: buttons },
+  };
+
+  if (messageId) {
+    await ctx.bot.editMessageText(text, {
+      chat_id: chatId,
+      message_id: messageId,
+      ...opts,
+    });
+  } else {
+    await ctx.bot.sendMessage(chatId, text, opts);
+  }
+}
+
+module.exports = { showWorkspaceMenu };

package/server/utils/telegramBot/utils/commands/index.js

@@ -0,0 +1,125 @@
+/**
+ * All command handler functions receive a `ctx` object:
+ * @typedef {object} BotContext
+ * @property {import('node-telegram-bot-api')} bot - The bot object.
+ * @property {object} config - The bot configuration.
+ * @property {(chatId: number) => { workspaceSlug: string, threadSlug: string | null }} getState - Get state for a chat.
+ * @property {(chatId: number, updates: object) => void} setState - Update state for a chat.
+ * @property {(text: string, ...args: any[]) => void} log - Log a message.
+ */
+
+/**
+ * @typedef {object} BotCommandConfig
+ * @property {string} command - The command name.
+ * @property {string} description - The command description.
+ * @property {boolean} skipAutoSetup - Whether to skip automatic setup.
+ * @property {() => (ctx: BotContext, chatId: number, messageText?: string) => Promise<void>} initHandler - The handler function to initialize the command.
+ */
+
+const BASE_COMMAND = {
+  skipAutoSetup: false,
+  initHandler: () => {
+    throw new Error("Not implemented");
+  },
+};
+
+/**
+ * @type {BotCommandConfig[]}
+ */
+const BOT_COMMANDS = [
+  {
+    ...BASE_COMMAND,
+    command: "start",
+    description: "Start the bot",
+    initHandler: () => {
+      const { handleStart } = require("./handlers/handleStart");
+      return handleStart;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "switch",
+    description: "Switch workspace or thread",
+    initHandler: () => {
+      const { showWorkspaceMenu } = require("./handlers/showWorkspaceMenu");
+      return showWorkspaceMenu;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "model",
+    description: "Change the LLM model",
+    initHandler: () => {
+      const { showModelMenu } = require("./handlers/showModelMenu");
+      return showModelMenu;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "new",
+    description: "Start a new thread",
+    initHandler: () => {
+      const { handleNewThread } = require("./handlers/handleNewThread");
+      return handleNewThread;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "history",
+    description: "Show recent messages (e.g. /history 25)",
+    skipAutoSetup: true,
+    initHandler: () => {
+      const { handleHistory } = require("./handlers/handleHistory");
+      return handleHistory;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "status",
+    description: "Show current workspace and model",
+    initHandler: () => {
+      const { handleStatus } = require("./handlers/handleStatus");
+      return handleStatus;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "reset",
+    description: "Clear chat history in current thread",
+    initHandler: () => {
+      const { handleReset } = require("./handlers/handleReset");
+      return handleReset;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "help",
+    description: "Show available commands",
+    initHandler: () => {
+      const { handleHelp } = require("./handlers/handleHelp");
+      return handleHelp;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "proof",
+    description: "Show citations for the last reply",
+    initHandler: () => {
+      const { handleProof } = require("./handlers/handleProof");
+      return handleProof;
+    },
+  },
+  {
+    ...BASE_COMMAND,
+    command: "abort",
+    description: "Stop the current response",
+    initHandler: () => {
+      const { handleAbort } = require("./handlers/handleAbort");
+      return handleAbort;
+    },
+  },
+];
+
+module.exports = {
+  BOT_COMMANDS,
+};

package/server/utils/telegramBot/utils/format.js

@@ -0,0 +1,225 @@
+/**
+ * Convert standard markdown to Telegram HTML format.
+ * Telegram HTML supports: <b>, <i>, <u>, <s>, <code>, <pre>, <a href="">, <tg-spoiler>
+ *
+ * @param {string} text - The markdown text to convert
+ * @param {object} [opts]
+ * @param {boolean} [opts.escapeHtml=true] - Whether to escape HTML in non-code text
+ * @param {boolean} [opts.closeUnclosedTags=true] - Whether to close unclosed HTML tags
+ * @returns {string} - HTML formatted text for Telegram
+ */
+function markdownToTelegram(
+  text,
+  { escapeHtml = true, closeUnclosedTags = true } = {}
+) {
+  if (!text) return "";
+
+  let result = text;
+
+  // Use null char placeholders that won't be affected by other transformations
+  const codeBlocks = [];
+  const inlineCode = [];
+  const thinkBlocks = [];
+
+  // Handle <think> blocks - including partial tags from split messages
+  // Process complete blocks first, then handle partials
+
+  // First: complete <think>...</think> blocks
+  result = result.replace(/<think>([\s\S]*?)<\/think>/g, (_, content) => {
+    const placeholder = `\x00THINKBLOCK${thinkBlocks.length}\x00`;
+    const trimmed = content.trim();
+    const tag = trimmed.length > 200 ? "blockquote expandable" : "blockquote";
+    thinkBlocks.push(
+      `<${tag}>💭 <b>Thinking:</b>\n${escapeHTML(trimmed)}</blockquote>`
+    );
+    return placeholder;
+  });
+
+  // Second: unclosed <think> tag (split message part 1)
+  if (result.includes("<think>")) {
+    result = result.replace(/<think>([\s\S]*)$/, (_, content) => {
+      const placeholder = `\x00THINKBLOCK${thinkBlocks.length}\x00`;
+      const trimmed = content.trim();
+      const tag = trimmed.length > 200 ? "blockquote expandable" : "blockquote";
+      thinkBlocks.push(
+        `<${tag}>💭 <b>Thinking:</b>\n${escapeHTML(trimmed)}</blockquote>`
+      );
+      return placeholder;
+    });
+  }
+
+  // Third: closing </think> without open (split message part 2)
+  if (result.includes("</think>")) {
+    result = result.replace(/([\s\S]*?)<\/think>/g, (_, content) => {
+      const placeholder = `\x00THINKBLOCK${thinkBlocks.length}\x00`;
+      const trimmed = content.trim();
+      const tag = trimmed.length > 200 ? "blockquote expandable" : "blockquote";
+      thinkBlocks.push(
+        `<${tag}>💭 <b>Thinking continued:</b>\n${escapeHTML(trimmed)}</blockquote>`
+      );
+      return placeholder;
+    });
+  }
+
+  // Extract fenced code blocks (```...```)
+  result = result.replace(/```(\w*)\n?([\s\S]*?)```/g, (_, lang, code) => {
+    const placeholder = `\x00CODEBLOCK${codeBlocks.length}\x00`;
+    codeBlocks.push(`<pre>${escapeHTML(code.trimEnd())}</pre>`);
+    return placeholder;
+  });
+
+  // Extract and convert markdown tables to preformatted text
+  result = result.replace(
+    /(?:^|\n)((?:\|[^\n]+\|(?:\n|$))+)/g,
+    (match, tableContent) => {
+      const converted = convertTableToPreformatted(tableContent);
+      const placeholder = `\x00CODEBLOCK${codeBlocks.length}\x00`;
+      codeBlocks.push(`<pre>${escapeHTML(converted)}</pre>`);
+      return `\n${placeholder}`;
+    }
+  );
+
+  // Extract inline code (`...`)
+  result = result.replace(/`([^`\n]+)`/g, (_, code) => {
+    const placeholder = `\x00INLINECODE${inlineCode.length}\x00`;
+    inlineCode.push(`<code>${escapeHTML(code)}</code>`);
+    return placeholder;
+  });
+
+  // Escape HTML in remaining text
+  if (escapeHtml) result = escapeHTML(result);
+
+  // Convert markdown to HTML (order matters - do bold before italic)
+  result = result.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  result = result.replace(/__(.+?)__/g, "<b>$1</b>");
+  result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
+  result = result.replace(
+    /(?<![a-zA-Z0-9])_([^_]+)_(?![a-zA-Z0-9])/g,
+    "<i>$1</i>"
+  );
+  result = result.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  result = result.replace(/^&gt;\s*(.+)$/gm, "<i>$1</i>");
+  result = result.replace(/^[-*_]{3,}$/gm, "————————————");
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+
+  // Convert list items: - item or * item → • item
+  result = result.replace(/^[-*]\s+/gm, "• ");
+
+  // Restore preserved blocks
+  thinkBlocks.forEach((block, i) => {
+    result = result.replace(`\x00THINKBLOCK${i}\x00`, block);
+  });
+  codeBlocks.forEach((block, i) => {
+    result = result.replace(`\x00CODEBLOCK${i}\x00`, block);
+  });
+  inlineCode.forEach((code, i) => {
+    result = result.replace(`\x00INLINECODE${i}\x00`, code);
+  });
+
+  // Close any unclosed HTML tags to prevent Telegram API errors during streaming
+  // since if you try to update a message with an unclosed tag, the API will return an 400 error
+  if (closeUnclosedTags) result = closeUnclosedHtmlTags(result);
+  return result;
+}
+
+/**
+ * Escape HTML special characters.
+ * @param {string} text
+ * @returns {string}
+ */
+function escapeHTML(text) {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+/**
+ * Close any unclosed HTML tags to prevent Telegram API errors.
+ * This is important during streaming when messages may be split mid-markdown.
+ * @param {string} html - The HTML text to fix
+ * @returns {string} - HTML with all tags properly closed
+ */
+function closeUnclosedHtmlTags(html) {
+  const tags = ["b", "i", "u", "s", "code", "pre", "a", "blockquote"];
+  const openTags = [];
+  const tagRegex = /<\/?([a-z]+)(?:\s[^>]*)?\s*\/?>/gi;
+  let match;
+
+  while ((match = tagRegex.exec(html)) !== null) {
+    const fullMatch = match[0];
+    const tagName = match[1].toLowerCase();
+
+    if (!tags.includes(tagName)) continue;
+    if (fullMatch.endsWith("/>")) continue;
+
+    if (fullMatch.startsWith("</")) {
+      const lastOpenIdx = openTags.lastIndexOf(tagName);
+      if (lastOpenIdx !== -1) {
+        openTags.splice(lastOpenIdx, 1);
+      }
+    } else {
+      openTags.push(tagName);
+    }
+  }
+
+  // Close any remaining open tags in reverse order
+  let result = html;
+  for (let i = openTags.length - 1; i >= 0; i--) {
+    result += `</${openTags[i]}>`;
+  }
+
+  return result;
+}
+
+/**
+ * Convert a markdown table to aligned preformatted text.
+ * @param {string} tableMarkdown
+ * @returns {string}
+ */
+function convertTableToPreformatted(tableMarkdown) {
+  const lines = tableMarkdown.trim().split("\n");
+  const rows = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const withoutPipes = trimmed.replace(/\|/g, "").trim();
+    if (/^[\s\-:]+$/.test(withoutPipes) && withoutPipes.includes("-")) continue;
+
+    const cells = line
+      .split("|")
+      .slice(1, -1)
+      .map((cell) => cell.trim());
+
+    if (cells.length > 0) rows.push(cells);
+  }
+
+  if (rows.length === 0) return tableMarkdown;
+
+  const colCount = Math.max(...rows.map((r) => r.length));
+  const colWidths = Array(colCount).fill(0);
+
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      colWidths[i] = Math.max(colWidths[i], row[i].length);
+    }
+  }
+
+  const output = [];
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx];
+    const paddedCells = row.map((cell, i) => cell.padEnd(colWidths[i]));
+    output.push(paddedCells.join(" │ "));
+    if (rowIdx === 0) {
+      output.push(colWidths.map((w) => "─".repeat(w)).join("─┼─"));
+    }
+  }
+
+  return output.join("\n");
+}
+
+module.exports = {
+  escapeHTML,
+  markdownToTelegram,
+};

package/server/utils/telegramBot/utils/index.js

@@ -0,0 +1,203 @@
+const { MAX_MSG_LEN } = require("../constants");
+const { markdownToTelegram } = require("../utils/format");
+const { EncryptionManager } = require("../../EncryptionManager");
+
+const ENCRYPTED_PREFIX = "enc:";
+
+/**
+ * Edit a Telegram message with truncation to stay under the 4096 char limit.
+ * @param {import("../commands").BotContext} ctx
+ * @param {number} chatId
+ * @param {number} messageId
+ * @param {string} text
+ * @param {function} log
+ * @param {object} [opts]
+ * @param {boolean} [opts.format=false] - Whether to format markdown as HTML
+ */
+async function editMessage(bot, chatId, messageId, text, log, opts = {}) {
+  if (!text || !bot) return;
+  const { format = false, html = false, disableLinkPreview = false } = opts;
+
+  let finalText = text;
+  let parseMode = undefined;
+
+  if (html) {
+    parseMode = "HTML";
+  } else if (format) {
+    try {
+      finalText = markdownToTelegram(text);
+      parseMode = "HTML";
+    } catch {
+      finalText = text;
+    }
+  }
+
+  const truncated =
+    finalText.length > 4096 ? finalText.slice(0, 4090) + "\n..." : finalText;
+
+  try {
+    await bot.editMessageText(truncated, {
+      chat_id: chatId,
+      message_id: messageId,
+      parse_mode: parseMode,
+      disable_web_page_preview: disableLinkPreview || undefined,
+    });
+  } catch (error) {
+    if (!error.message?.includes("message is not modified")) {
+      log("Edit error:", error.message);
+    }
+    // If HTML parsing failed, retry without formatting
+    if (parseMode && error.message?.includes("parse")) {
+      try {
+        const plainTruncated =
+          text.length > 4096 ? text.slice(0, 4090) + "\n..." : text;
+        await bot.editMessageText(plainTruncated, {
+          chat_id: chatId,
+          message_id: messageId,
+          disable_web_page_preview: disableLinkPreview || undefined,
+        });
+      } catch {}
+    }
+  }
+}
+
+/**
+ * Send a formatted message to Telegram with markdown converted to HTML.
+ * Falls back to plain text if HTML parsing fails.
+ * @param {TelegramBot} bot
+ * @param {number} chatId
+ * @param {string} text
+ * @param {object} [opts]
+ * @param {boolean} [opts.format=true] - Whether to format markdown as HTML
+ * @param {boolean} [opts.escapeHtml=true] - Whether to escape HTML tags in non-code text (unsafe - use only with fixed input)
+ * @returns {Promise<object>} The sent message object
+ */
+async function sendFormattedMessage(bot, chatId, text, opts = {}) {
+  const { format = true, escapeHtml = true } = opts;
+
+  if (!format) {
+    return bot.sendMessage(chatId, text);
+  }
+
+  try {
+    const formatted = markdownToTelegram(text, { escapeHtml });
+    return await bot.sendMessage(chatId, formatted, { parse_mode: "HTML" });
+  } catch (error) {
+    // If HTML parsing failed, retry without formatting
+    if (error.message?.includes("parse") || error.message?.includes("can't")) {
+      return bot.sendMessage(chatId, text);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Send a list of text blocks as batched Telegram messages that
+ * stay under the 4096 char limit. Blocks are joined with the
+ * given separator and split into new messages when they'd overflow.
+ * @param {TelegramBot} bot
+ * @param {number} chatId
+ * @param {string[]} blocks - individual text blocks to send
+ * @param {object} [opts]
+ * @param {string} [opts.header] - text prepended to the first message
+ * @param {string} [opts.separator] - string between blocks (default "\n\n")
+ * @param {object} [opts.sendOptions] - extra options passed to sendMessage (e.g. parse_mode)
+ */
+async function sendBatchedMessages(bot, chatId, blocks, opts = {}) {
+  const { header = "", separator = "\n\n", sendOptions = {} } = opts;
+  if (!blocks.length) return;
+
+  let currentMsg = header;
+
+  for (let i = 0; i < blocks.length; i++) {
+    const addition = (i === 0 ? "" : separator) + blocks[i];
+
+    if (currentMsg.length + addition.length > MAX_MSG_LEN) {
+      await bot.sendMessage(chatId, currentMsg.trim(), sendOptions);
+      currentMsg = blocks[i];
+    } else {
+      currentMsg += addition;
+    }
+  }
+
+  if (currentMsg.trim()) {
+    await bot.sendMessage(chatId, currentMsg.trim(), sendOptions);
+  }
+}
+
+/**
+ * Encrypt a bot token for safe storage in the database.
+ * @param {string} token
+ * @returns {string|null}
+ */
+function encryptToken(token) {
+  if (!token) return null;
+  const manager = new EncryptionManager();
+  const encrypted = manager.encrypt(token);
+  return encrypted ? ENCRYPTED_PREFIX + encrypted : null;
+}
+
+/**
+ * Decrypt an encrypted bot token from the database.
+ * Returns plaintext tokens as-is for backward compatibility.
+ * @param {string} encryptedToken
+ * @returns {string|null}
+ */
+function decryptToken(encryptedToken) {
+  if (!encryptedToken) return null;
+  if (!encryptedToken.startsWith(ENCRYPTED_PREFIX)) return encryptedToken;
+  const manager = new EncryptionManager();
+  return manager.decrypt(encryptedToken.slice(ENCRYPTED_PREFIX.length));
+}
+
+/**
+ * Resolve the LLM provider for a workspace.
+ * @param {object} workspace
+ * @returns {{ provider: string, model: string }}
+ */
+function resolveWorkspaceProvider(workspace) {
+  const { getBaseLLMProviderModel } = require("../../helpers");
+  const provider =
+    workspace?.agentProvider ??
+    workspace?.chatProvider ??
+    process.env.LLM_PROVIDER;
+  const model =
+    workspace?.agentModel ??
+    workspace?.chatModel ??
+    getBaseLLMProviderModel({ provider });
+  return { provider, model };
+}
+
+/**
+ * Send a new message or edit an existing one (upsert pattern).
+ * @param {import('../commands').BotContext} ctx
+ * @param {number} chatId
+ * @param {number|null} msgId - Existing message ID, or null to send new
+ * @param {string} text
+ * @param {object} [log]
+ * @param {object} [opts]
+ * @param {boolean} [opts.html=false] - Whether text is pre-formatted HTML
+ * @returns {Promise<number>} The message ID (new or existing)
+ */
+async function upsertMessage(bot, chatId, msgId, text, log, opts = {}) {
+  const { html = false, disableLinkPreview = false } = opts;
+  if (!msgId) {
+    const sent = await bot.sendMessage(chatId, text, {
+      parse_mode: html ? "HTML" : undefined,
+      disable_web_page_preview: disableLinkPreview || undefined,
+    });
+    return sent.message_id;
+  }
+  await editMessage(bot, chatId, msgId, text, log, opts);
+  return msgId;
+}
+
+module.exports = {
+  editMessage,
+  upsertMessage,
+  sendBatchedMessages,
+  sendFormattedMessage,
+  encryptToken,
+  decryptToken,
+  resolveWorkspaceProvider,
+};