totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/create-files/index.js

@@ -0,0 +1,23 @@
+const { CreatePptxPresentation } = require("./pptx/create-presentation.js");
+const { CreateTextFile } = require("./text/create-text-file.js");
+const { CreatePdfFile } = require("./pdf/create-pdf-file.js");
+const { CreateExcelFile } = require("./xlsx/create-excel-file.js");
+const { CreateDocxFile } = require("./docx/create-docx-file.js");
+
+const createFilesAgent = {
+  name: "create-files-agent",
+  startupConfig: {
+    params: {},
+  },
+  plugin: [
+    CreatePptxPresentation,
+    CreateTextFile,
+    CreatePdfFile,
+    CreateExcelFile,
+    CreateDocxFile,
+  ],
+};
+
+module.exports = {
+  createFilesAgent,
+};

package/server/utils/agents/aibitat/plugins/create-files/lib.js

@@ -0,0 +1,300 @@
+const path = require("path");
+const fs = require("fs/promises");
+const fsSync = require("fs");
+const { v4: uuidv4 } = require("uuid");
+
+/**
+ * Manages file creation operations for binary document formats.
+ * Handles both browser download and filesystem write modes.
+ * All generated files are saved to storage/generated-files directory.
+ */
+class CreateFilesManager {
+  #outputDirectory = null;
+  #isInitialized = false;
+
+  /**
+   * Gets the output directory for generated files.
+   * @returns {string} The output directory path (storage/generated-files)
+   */
+  #getOutputDirectory() {
+    const storageRoot =
+      process.env.STORAGE_DIR ||
+      path.resolve(__dirname, "../../../../../storage");
+    return path.join(storageRoot, "generated-files");
+  }
+
+  /**
+   * Initializes the create-files manager and ensures output directory exists.
+   * @returns {Promise<string>} The output directory path
+   */
+  async #initialize() {
+    this.#outputDirectory = this.#getOutputDirectory();
+
+    try {
+      await fs.mkdir(this.#outputDirectory, { recursive: true });
+    } catch (error) {
+      console.error(
+        `Warning: Could not create output directory ${this.#outputDirectory}: ${error.message}`
+      );
+    }
+
+    this.#isInitialized = true;
+    return this.#outputDirectory;
+  }
+
+  /**
+   * Ensures the create-files manager is initialized before use.
+   * @returns {Promise<void>}
+   */
+  async ensureInitialized() {
+    if (!this.#isInitialized) await this.#initialize();
+  }
+
+  /**
+   * Checks if file creation tools are available.
+   * @returns {boolean} True if tools are available
+   */
+  isToolAvailable() {
+    if (process.env.NODE_ENV === "development") return true;
+    return process.env.ANYTHING_LLM_RUNTIME === "docker";
+  }
+
+  /**
+   * Gets the output directory path.
+   * @returns {Promise<string>} The output directory path
+   */
+  async getOutputDirectory() {
+    await this.ensureInitialized();
+    return this.#outputDirectory;
+  }
+
+  /**
+   * Writes binary content (Buffer) to a file.
+   * @param {string} filePath - Validated absolute path to write to
+   * @param {Buffer} buffer - Binary content to write
+   * @returns {Promise<void>}
+   */
+  async writeBinaryFile(filePath, buffer) {
+    const parentDir = path.dirname(filePath);
+    const fileSizeBytes = buffer.length;
+    const fileSizeKB = (fileSizeBytes / 1024).toFixed(2);
+    const fileSizeMB = (fileSizeBytes / (1024 * 1024)).toFixed(2);
+
+    console.log(
+      `[CreateFilesManager] writeBinaryFile starting - path: ${filePath}, size: ${fileSizeKB}KB (${fileSizeMB}MB)`
+    );
+
+    await fs.mkdir(parentDir, { recursive: true });
+    await fs.writeFile(filePath, buffer);
+
+    console.log(
+      `[CreateFilesManager] writeBinaryFile completed - file saved to: ${filePath}`
+    );
+  }
+
+  /**
+   * Gets the MIME type for a file extension.
+   * @param {string} extension - File extension (with or without dot)
+   * @returns {string} MIME type
+   */
+  getMimeType(extension) {
+    const ext = extension.startsWith(".") ? extension : `.${extension}`;
+    const mimeTypes = {
+      ".pptx":
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      ".xlsx":
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".docx":
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".pdf": "application/pdf",
+      ".txt": "text/plain",
+      ".csv": "text/csv",
+      ".json": "application/json",
+      ".html": "text/html",
+      ".xml": "application/xml",
+      ".zip": "application/zip",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".mp3": "audio/mpeg",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+    };
+    return mimeTypes[ext.toLowerCase()] || "application/octet-stream";
+  }
+
+  /**
+   * Checks if a file exists.
+   * @param {string} filePath - Path to check
+   * @returns {Promise<boolean>} True if file exists
+   */
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Reads a file as a Buffer.
+   * @param {string} filePath - Path to the file
+   * @returns {Promise<Buffer>} File content as Buffer
+   */
+  async readBinaryFile(filePath) {
+    return await fs.readFile(filePath);
+  }
+
+  /**
+   * Registers an output to be persisted in the chat history.
+   * This allows files and other outputs to be re-rendered when viewing historical messages.
+   * @param {object} aibitat - The aibitat instance to register the output on
+   * @param {string} type - The type of output (e.g., "PptxFileDownload")
+   * @param {object} payload - The output payload data
+   */
+  registerOutput(aibitat, type, payload) {
+    if (!aibitat) {
+      console.warn(
+        "[CreateFilesManager] Cannot register output - aibitat instance not provided"
+      );
+      return;
+    }
+
+    if (!aibitat._pendingOutputs) {
+      aibitat._pendingOutputs = [];
+    }
+
+    aibitat._pendingOutputs.push({ type, payload });
+    console.log(
+      `[CreateFilesManager] Registered output: type=${type}, total pending=${aibitat._pendingOutputs.length}`
+    );
+  }
+
+  /**
+   * Generates a standardized filename for generated files.
+   * Format: {fileType}-{fileUUID}.{extension}
+   * @param {string} fileType - Type identifier (e.g., 'pptx', 'xlsx')
+   * @param {string} extension - File extension (without dot)
+   * @returns {string} The generated filename
+   */
+  generateFilename(fileType, extension) {
+    const fileUUID = uuidv4();
+    return `${fileType}-${fileUUID}.${extension}`;
+  }
+
+  /**
+   * Parses a generated filename to extract its components.
+   * @param {string} filename - The filename to parse
+   * @returns {{fileType: string, fileUUID: string, extension: string} | null}
+   */
+  parseFilename(filename) {
+    const match = filename.match(/^([a-z]+)-([a-f0-9-]{36})\.(\w+)$/i);
+    if (!match) return null;
+    return {
+      fileType: match[1],
+      fileUUID: match[2],
+      extension: match[3],
+    };
+  }
+
+  /**
+   * Saves a generated file to storage and returns metadata for WebSocket/DB storage.
+   * This is the primary method for persisting agent-generated files.
+   * @param {object} params
+   * @param {string} params.fileType - Type identifier (e.g., 'pptx', 'xlsx')
+   * @param {string} params.extension - File extension (without dot)
+   * @param {Buffer} params.buffer - The file content as a Buffer
+   * @param {string} params.displayFilename - The user-friendly filename for display
+   * @returns {Promise<{filename: string, displayFilename: string, fileSize: number, storagePath: string}>}
+   */
+  async saveGeneratedFile({ fileType, extension, buffer, displayFilename }) {
+    await this.ensureInitialized();
+
+    const filename = this.generateFilename(fileType, extension);
+    const storagePath = path.join(this.#outputDirectory, filename);
+
+    await this.writeBinaryFile(storagePath, buffer);
+
+    console.log(
+      `[CreateFilesManager] saveGeneratedFile - saved ${filename} (${(buffer.length / 1024).toFixed(2)}KB)`
+    );
+
+    return {
+      filename,
+      displayFilename,
+      fileSize: buffer.length,
+      storagePath,
+    };
+  }
+
+  /**
+   * Retrieves a generated file by its storage filename.
+   * @param {string} filename - The storage filename (must match {fileType}-{uuid}.{ext} format)
+   * @returns {Promise<{buffer: Buffer, storagePath: string} | null>}
+   */
+  async getGeneratedFile(filename) {
+    await this.ensureInitialized();
+
+    // Defense-in-depth: validate filename format to prevent path traversal
+    if (!this.parseFilename(filename)) {
+      console.warn(
+        `[CreateFilesManager] getGeneratedFile - rejected invalid filename format: ${filename}`
+      );
+      return null;
+    }
+
+    const storagePath = path.join(this.#outputDirectory, filename);
+    const exists = await this.fileExists(storagePath);
+    if (!exists) return null;
+
+    const buffer = await this.readBinaryFile(storagePath);
+    return { buffer, storagePath };
+  }
+
+  /**
+   * Sanitizes a filename for use in Content-Disposition header to prevent header injection.
+   * Removes/replaces characters that could be used for header manipulation.
+   * @param {string} filename - The filename to sanitize
+   * @returns {string} Sanitized filename safe for Content-Disposition header
+   */
+  sanitizeFilenameForHeader(filename) {
+    if (!filename || typeof filename !== "string") return "download";
+    return filename
+      .replace(/[\r\n"\\]/g, "_")
+      .replace(/[^\x20-\x7E]/g, "_")
+      .substring(0, 255);
+  }
+
+  /**
+   * Gets the AnythingLLM logo for branding.
+   * @param {Object} options
+   * @param {boolean} [options.forDarkBackground=false] - True to get light logo (for dark backgrounds), false for dark logo (for light backgrounds)
+   * @param {"buffer"|"dataUri"} [options.format="buffer"] - Return format: "buffer" for raw Buffer, "dataUri" for base64 data URI
+   * @returns {Buffer|string|null} Logo as Buffer, data URI string, or null if file not found
+   */
+  getLogo({ forDarkBackground = false, format = "buffer" } = {}) {
+    // On Docker this is pre-packed images local to this lib.
+    // Does not honor Whitelabeling changes/preferences right now.
+    const assetsPath = path.join(__dirname, "assets");
+    const filename = forDarkBackground
+      ? "anything-llm.png"
+      : "anything-llm-invert.png";
+    try {
+      if (format === "dataUri") {
+        const base64 = fsSync.readFileSync(
+          path.join(assetsPath, filename),
+          "base64"
+        );
+        return `image/png;base64,${base64}`;
+      }
+      return fsSync.readFileSync(path.join(assetsPath, filename));
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = new CreateFilesManager();

package/server/utils/agents/aibitat/plugins/create-files/pdf/create-pdf-file.js

@@ -0,0 +1,138 @@
+const createFilesLib = require("../lib.js");
+const { applyBranding } = require("./utils.js");
+
+module.exports.CreatePdfFile = {
+  name: "create-pdf-file",
+  plugin: function () {
+    return {
+      name: "create-pdf-file",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Create a PDF document from markdown or plain text content. " +
+            "The content will be styled and converted to a professional PDF document. " +
+            "Supports markdown formatting including headers, lists, code blocks, tables, and more.",
+          examples: [
+            {
+              prompt: "Create a PDF report about quarterly sales",
+              call: JSON.stringify({
+                filename: "quarterly-sales-report.pdf",
+                content:
+                  "# Quarterly Sales Report\n\n## Q1 2024 Summary\n\n### Key Metrics\n- Total Revenue: $1.2M\n- Growth: 15% YoY\n- New Customers: 234\n\n### Top Products\n1. Product A - $400K\n2. Product B - $350K\n3. Product C - $250K\n\n## Recommendations\n\nBased on the analysis, we recommend focusing on...",
+              }),
+            },
+            {
+              prompt: "Create a PDF document with meeting minutes",
+              call: JSON.stringify({
+                filename: "meeting-minutes.pdf",
+                content:
+                  "# Team Meeting Minutes\n\n**Date:** January 15, 2024\n**Attendees:** John, Sarah, Mike, Lisa\n\n## Agenda Items\n\n### 1. Project Status Update\nThe project is on track for Q2 delivery. Key milestones:\n- [ ] Phase 1 complete\n- [x] Phase 2 in progress\n- [ ] Phase 3 pending\n\n### 2. Budget Review\n| Category | Allocated | Spent |\n|----------|-----------|-------|\n| Development | $50,000 | $35,000 |\n| Marketing | $20,000 | $12,000 |\n\n### Action Items\n- John: Complete technical review by Friday\n- Sarah: Schedule stakeholder meeting",
+              }),
+            },
+            {
+              prompt: "Create a PDF with code documentation",
+              call: JSON.stringify({
+                filename: "api-documentation.pdf",
+                content:
+                  "# API Documentation\n\n## Authentication\n\nAll API requests require a Bearer token:\n\n```javascript\nfetch('/api/data', {\n  headers: {\n    'Authorization': 'Bearer YOUR_TOKEN'\n  }\n});\n```\n\n## Endpoints\n\n### GET /api/users\n\nReturns a list of all users.\n\n**Response:**\n```json\n{\n  \"users\": [...],\n  \"total\": 100\n}\n```",
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              filename: {
+                type: "string",
+                description:
+                  "The filename for the PDF document. The .pdf extension will be added automatically if not provided.",
+              },
+              content: {
+                type: "string",
+                description:
+                  "The markdown or plain text content to convert to PDF. Supports full markdown syntax including headers (#, ##, ###), bold (**text**), italic (*text*), lists, code blocks, tables, and more.",
+              },
+            },
+            required: ["filename", "content"],
+            additionalProperties: false,
+          },
+          handler: async function ({
+            filename = "document.pdf",
+            content = "",
+          }) {
+            try {
+              this.super.handlerProps.log(`Using the create-pdf-file tool.`);
+
+              const hasExtension = /\.pdf$/i.test(filename);
+              if (!hasExtension) filename = `${filename}.pdf`;
+
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: { filename },
+                  description: `Create PDF document "${filename}"`,
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              this.super.introspect(
+                `${this.caller}: Creating PDF document "${filename}"`
+              );
+
+              const { markdownToPdf } = await import("@mintplex-labs/mdpdf");
+              const { PDFDocument, rgb, StandardFonts } = await import(
+                "pdf-lib"
+              );
+
+              const rawBuffer = await markdownToPdf(content);
+              const pdfDoc = await PDFDocument.load(rawBuffer);
+              await applyBranding(pdfDoc, { rgb, StandardFonts });
+
+              const buffer = await pdfDoc.save();
+              const bufferSizeKB = (buffer.length / 1024).toFixed(2);
+              const displayFilename = filename.split("/").pop();
+
+              const savedFile = await createFilesLib.saveGeneratedFile({
+                fileType: "pdf",
+                extension: "pdf",
+                buffer,
+                displayFilename,
+              });
+
+              this.super.socket.send("fileDownloadCard", {
+                filename: savedFile.displayFilename,
+                storageFilename: savedFile.filename,
+                fileSize: savedFile.fileSize,
+              });
+
+              createFilesLib.registerOutput(this.super, "PdfFileDownload", {
+                filename: savedFile.displayFilename,
+                storageFilename: savedFile.filename,
+                fileSize: savedFile.fileSize,
+              });
+
+              this.super.introspect(
+                `${this.caller}: Successfully created PDF document "${displayFilename}"`
+              );
+
+              return `Successfully created PDF document "${displayFilename}" (${bufferSizeKB}KB).`;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `create-pdf-file error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error creating PDF document: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/create-files/pdf/utils.js

@@ -0,0 +1,70 @@
+const createFilesLib = require("../lib.js");
+
+/**
+ * Applies AnythingLLM branding to a PDF document.
+ * Adds a logo watermark or fallback text to the bottom-right of each page.
+ * @param {PDFDocument} pdfDoc - The pdf-lib PDFDocument instance
+ * @param {Object} pdfLib - The pdf-lib module exports (rgb, StandardFonts)
+ * @returns {Promise<void>}
+ */
+async function applyBranding(pdfDoc, { rgb, StandardFonts }) {
+  const font = await pdfDoc.embedFont(StandardFonts.HelveticaOblique);
+  const pages = pdfDoc.getPages();
+
+  const logoPng = createFilesLib.getLogo({
+    forDarkBackground: false,
+    format: "buffer",
+  });
+  const logoImage = logoPng ? await pdfDoc.embedPng(logoPng) : null;
+
+  const logoWidth = 80;
+  const logoHeight = logoImage
+    ? (logoImage.height / logoImage.width) * logoWidth
+    : 0;
+
+  const marginRight = 20;
+  const marginBottom = 20;
+
+  for (const page of pages) {
+    const { width } = page.getSize();
+
+    if (logoImage) {
+      const createdWithText = "created with";
+      const fontSize = 7;
+      const textWidth = font.widthOfTextAtSize(createdWithText, fontSize);
+      const logoX = width - marginRight - logoWidth;
+
+      page.drawText(createdWithText, {
+        x: logoX + (logoWidth - textWidth) / 2,
+        y: marginBottom + logoHeight + 2,
+        size: fontSize,
+        font,
+        color: rgb(0.6, 0.6, 0.6),
+        opacity: 0.6,
+      });
+
+      page.drawImage(logoImage, {
+        x: logoX,
+        y: marginBottom,
+        width: logoWidth,
+        height: logoHeight,
+        opacity: 0.6,
+      });
+    } else {
+      const fallbackText = "Created with AnythingLLM";
+      const fontSize = 9;
+      const textWidth = font.widthOfTextAtSize(fallbackText, fontSize);
+      page.drawText(fallbackText, {
+        x: width - marginRight - textWidth,
+        y: marginBottom,
+        size: fontSize,
+        font,
+        color: rgb(0.6, 0.6, 0.6),
+      });
+    }
+  }
+}
+
+module.exports = {
+  applyBranding,
+};