totem-llm 0.1.0

package/server/endpoints/agentFileServer.js

@@ -0,0 +1,174 @@
+const {
+  userFromSession,
+  multiUserMode,
+  safeJsonParse,
+} = require("../utils/http");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../utils/middleware/multiUserProtected");
+const { WorkspaceChats } = require("../models/workspaceChats");
+const { Workspace } = require("../models/workspace");
+const { ScheduledJobRun } = require("../models/scheduledJobRun");
+const createFilesLib = require("../utils/agents/aibitat/plugins/create-files/lib");
+
+/**
+ * Endpoints for serving agent-generated files (PPTX, etc.) with authentication
+ * and ownership validation.
+ */
+function agentFileServerEndpoints(app) {
+  if (!app) return;
+
+  /**
+   * Download a generated file by its storage filename.
+   * Validates that the requesting user has access to the workspace
+   * where the file was generated.
+   */
+  app.get(
+    "/agent-skills/generated-files/:filename",
+    [validatedRequest, flexUserRoleValid([ROLES.all])],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const { filename } = request.params;
+        if (!filename)
+          return response.status(400).json({ error: "Filename is required" });
+
+        // Validate filename format
+        const parsed = createFilesLib.parseFilename(filename);
+        if (!parsed) {
+          return response
+            .status(400)
+            .json({ error: "Invalid filename format" });
+        }
+
+        // Find a chat or scheduled job run that references this file
+        const fileSource = await findFileSource(filename, {
+          user,
+          isMultiUser: multiUserMode(response),
+        });
+
+        if (!fileSource) {
+          return response.status(404).json({
+            error: "File not found or access denied",
+          });
+        }
+
+        // Retrieve the file from storage
+        const fileData = await createFilesLib.getGeneratedFile(filename);
+        if (!fileData) {
+          return response
+            .status(404)
+            .json({ error: "File not found in storage" });
+        }
+
+        // Get mime type and set headers for download
+        const mimeType = createFilesLib.getMimeType(`.${parsed.extension}`);
+        const safeFilename = createFilesLib.sanitizeFilenameForHeader(
+          fileSource.displayFilename || filename
+        );
+        response.setHeader("Content-Type", mimeType);
+        response.setHeader(
+          "Content-Disposition",
+          `attachment; filename="${safeFilename}"`
+        );
+        response.setHeader("Content-Length", fileData.buffer.length);
+        response.send(fileData.buffer);
+        return;
+      } catch (error) {
+        console.error("[agentFileServer] Download error:", error.message);
+        return response.status(500).json({ error: "Failed to download file" });
+      }
+    }
+  );
+}
+
+/**
+ * Locates the source record (a workspace chat or a scheduled job run) that
+ * references the given storage filename, and confirms the requester has access.
+ *
+ * Search order:
+ *   1. Workspace chats the user can access (per multi-user permissions).
+ *   2. Scheduled job runs — single-user only, so no per-user access check.
+ *
+ * @param {string} storageFilename
+ * @param {{ user: object|null, isMultiUser: boolean }} ctx
+ * @returns {Promise<{workspaceId: number|null, displayFilename: string}|null>}
+ */
+async function findFileSource(storageFilename, { user, isMultiUser }) {
+  try {
+    const fromChat = await findInWorkspaceChats(storageFilename, {
+      user,
+      isMultiUser,
+    });
+    if (fromChat) return fromChat;
+
+    if (isMultiUser) return null;
+
+    return await findInScheduledJobRuns(storageFilename);
+  } catch (error) {
+    console.error("[findFileSource] Error:", error.message);
+    return null;
+  }
+}
+
+// Search workspace chats the user has access to. In single-user mode all
+// workspaces are accessible; in multi-user mode only workspaces assigned to
+// the user are. Returns the matching chat's workspace + display filename.
+async function findInWorkspaceChats(storageFilename, { user, isMultiUser }) {
+  const workspaces =
+    isMultiUser && user
+      ? await Workspace.whereWithUser(user)
+      : await Workspace.where();
+
+  const workspaceIds = workspaces.map((w) => w.id);
+  if (workspaceIds.length === 0) return null;
+
+  // DB-level filter so we don't load every chat into memory.
+  const chats = await WorkspaceChats.where({
+    workspaceId: { in: workspaceIds },
+    include: true,
+    response: { contains: storageFilename },
+  });
+
+  for (const chat of chats) {
+    const { outputs = [] } = safeJsonParse(chat.response, { outputs: [] });
+    const output = outputs.find(
+      (o) => o?.payload?.storageFilename === storageFilename
+    );
+    if (!output) continue;
+    return {
+      workspaceId: chat.workspaceId,
+      displayFilename:
+        output.payload.filename || output.payload.displayFilename,
+    };
+  }
+
+  return null;
+}
+
+// Search completed scheduled job runs. Scheduled jobs are single-user only,
+// so this skips access control. Returns the matching run's display filename.
+async function findInScheduledJobRuns(storageFilename) {
+  const runs = await ScheduledJobRun.where({
+    status: "completed",
+    result: { contains: storageFilename },
+  });
+
+  for (const run of runs) {
+    const { outputs = [] } = safeJsonParse(run.result, { outputs: [] });
+    const output = outputs.find(
+      (o) => o?.payload?.storageFilename === storageFilename
+    );
+    if (!output) continue;
+    return {
+      workspaceId: null,
+      displayFilename: output.payload.filename || storageFilename,
+    };
+  }
+
+  return null;
+}
+
+module.exports = { agentFileServerEndpoints };

package/server/endpoints/agentFlows.js

@@ -0,0 +1,192 @@
+const { AgentFlows } = require("../utils/agentFlows");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../utils/middleware/multiUserProtected");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+
+function agentFlowEndpoints(app) {
+  if (!app) return;
+
+  // Save a flow configuration
+  app.post(
+    "/agent-flows/save",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { name, config, uuid } = request.body;
+
+        if (!name || !config) {
+          return response.status(400).json({
+            success: false,
+            error: "Name and config are required",
+          });
+        }
+
+        const flow = AgentFlows.saveFlow(name, config, uuid);
+        if (!flow || !flow.success)
+          return response
+            .status(200)
+            .json({ flow: null, error: flow.error || "Failed to save flow" });
+
+        if (!uuid) {
+        }
+
+        return response.status(200).json({
+          success: true,
+          flow,
+        });
+      } catch (error) {
+        console.error("Error saving flow:", error);
+        return response.status(500).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  // List all available flows
+  app.get(
+    "/agent-flows/list",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_request, response) => {
+      try {
+        const flows = AgentFlows.listFlows();
+        return response.status(200).json({
+          success: true,
+          flows,
+        });
+      } catch (error) {
+        console.error("Error listing flows:", error);
+        return response.status(500).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  // Get a specific flow by UUID
+  app.get(
+    "/agent-flows/:uuid",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { uuid } = request.params;
+        const flow = AgentFlows.loadFlow(uuid);
+        if (!flow) {
+          return response.status(404).json({
+            success: false,
+            error: "Flow not found",
+          });
+        }
+
+        return response.status(200).json({
+          success: true,
+          flow,
+        });
+      } catch (error) {
+        console.error("Error getting flow:", error);
+        return response.status(500).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  // Run a specific flow
+  // app.post(
+  //   "/agent-flows/:uuid/run",
+  //   [validatedRequest, flexUserRoleValid([ROLES.admin])],
+  //   async (request, response) => {
+  //     try {
+  //       const { uuid } = request.params;
+  //       const { variables = {} } = request.body;
+
+  //       // TODO: Implement flow execution
+  //       console.log("Running flow with UUID:", uuid);
+
+  //       return response.status(200).json({
+  //         success: true,
+  //         results: {
+  //           success: true,
+  //           results: "test",
+  //           variables: variables,
+  //         },
+  //       });
+  //     } catch (error) {
+  //       console.error("Error running flow:", error);
+  //       return response.status(500).json({
+  //         success: false,
+  //         error: error.message,
+  //       });
+  //     }
+  //   }
+  // );
+
+  // Delete a specific flow
+  app.delete(
+    "/agent-flows/:uuid",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { uuid } = request.params;
+        const { success } = AgentFlows.deleteFlow(uuid);
+
+        if (!success) {
+          return response.status(500).json({
+            success: false,
+            error: "Failed to delete flow",
+          });
+        }
+
+        return response.status(200).json({
+          success,
+        });
+      } catch (error) {
+        console.error("Error deleting flow:", error);
+        return response.status(500).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    }
+  );
+
+  // Toggle flow active status
+  app.post(
+    "/agent-flows/:uuid/toggle",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { uuid } = request.params;
+        const { active } = request.body;
+
+        const flow = AgentFlows.loadFlow(uuid);
+        if (!flow) {
+          return response
+            .status(404)
+            .json({ success: false, error: "Flow not found" });
+        }
+
+        flow.config.active = active;
+        const { success } = AgentFlows.saveFlow(flow.name, flow.config, uuid);
+
+        if (!success) {
+          return response
+            .status(500)
+            .json({ success: false, error: "Failed to update flow" });
+        }
+
+        return response.json({ success: true, flow });
+      } catch (error) {
+        console.error("Error toggling flow:", error);
+        response.status(500).json({ success: false, error: error.message });
+      }
+    }
+  );
+}
+
+module.exports = { agentFlowEndpoints };

package/server/endpoints/agentSkillWhitelist.js

@@ -0,0 +1,82 @@
+const { AgentSkillWhitelist } = require("../models/agentSkillWhitelist");
+const { reqBody, userFromSession } = require("../utils/http");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../utils/middleware/multiUserProtected");
+
+function agentSkillWhitelistEndpoints(app) {
+  if (!app) return;
+
+  app.get(
+    "/agent-skills/filesystem-agent/is-available",
+    [validatedRequest],
+    async (_request, response) => {
+      try {
+        const filesystemTool = require("../utils/agents/aibitat/plugins/filesystem/lib");
+        return response
+          .status(200)
+          .json({ available: filesystemTool.isToolAvailable() });
+      } catch (e) {
+        console.error(e);
+        return response
+          .status(500)
+          .json({ available: false, error: e.message });
+      }
+    }
+  );
+
+  app.get(
+    "/agent-skills/create-files-agent/is-available",
+    [validatedRequest],
+    async (_request, response) => {
+      try {
+        const createFilesTool = require("../utils/agents/aibitat/plugins/create-files/lib");
+        return response
+          .status(200)
+          .json({ available: createFilesTool.isToolAvailable() });
+      } catch (e) {
+        console.error(e);
+        return response
+          .status(500)
+          .json({ available: false, error: e.message });
+      }
+    }
+  );
+
+  app.post(
+    "/agent-skills/whitelist/add",
+    [validatedRequest, flexUserRoleValid(ROLES.all)],
+    async (request, response) => {
+      try {
+        const { skillName } = reqBody(request);
+        if (!skillName) {
+          response
+            .status(400)
+            .json({ success: false, error: "Missing skillName" });
+          return;
+        }
+
+        const user = await userFromSession(request, response);
+        if (!user && response.locals?.multiUserMode) {
+          return response
+            .status(401)
+            .json({ success: false, error: "Unauthorized" });
+        }
+
+        const userId = user?.id || null;
+        const { success, error } = await AgentSkillWhitelist.add(
+          skillName,
+          userId
+        );
+        return response.status(success ? 200 : 400).json({ success, error });
+      } catch (e) {
+        console.error(e);
+        return response.status(500).json({ success: false, error: e.message });
+      }
+    }
+  );
+}
+
+module.exports = { agentSkillWhitelistEndpoints };

package/server/endpoints/agentWebsocket.js

@@ -0,0 +1,62 @@
+const {
+  WorkspaceAgentInvocation,
+} = require("../models/workspaceAgentInvocation");
+const { AgentHandler } = require("../utils/agents");
+const {
+  WEBSOCKET_BAIL_COMMANDS,
+} = require("../utils/agents/aibitat/plugins/websocket");
+const { safeJsonParse } = require("../utils/http");
+
+// Setup listener for incoming messages to relay to socket so it can be handled by agent plugin.
+function relayToSocket(message) {
+  if (this.handleFeedback) return this?.handleFeedback?.(message);
+  if (this.handleToolApproval) return this?.handleToolApproval?.(message);
+  if (this.handleClarificationResponse)
+    return this?.handleClarificationResponse?.(message);
+  this.checkBailCommand(message);
+}
+
+function agentWebsocket(app) {
+  if (!app) return;
+
+  app.ws("/agent-invocation/:uuid", async function (socket, request) {
+    try {
+      const agentHandler = await new AgentHandler({
+        uuid: String(request.params.uuid),
+      }).init();
+
+      if (!agentHandler.invocation) {
+        socket.close();
+        return;
+      }
+
+      socket.on("message", relayToSocket);
+      socket.on("close", () => {
+        agentHandler.closeAlert();
+        WorkspaceAgentInvocation.close(String(request.params.uuid));
+        return;
+      });
+
+      socket.checkBailCommand = (data) => {
+        const content = safeJsonParse(data)?.feedback;
+        if (WEBSOCKET_BAIL_COMMANDS.includes(content)) {
+          agentHandler.log(
+            `User invoked bail command while processing. Closing session now.`
+          );
+          agentHandler.aibitat.abort();
+          socket.close();
+          return;
+        }
+      };
+
+      await agentHandler.createAIbitat({ socket });
+      await agentHandler.startAgentCluster();
+    } catch (e) {
+      console.error(e.message, e);
+      socket?.send(JSON.stringify({ type: "wssFailure", content: e.message }));
+      socket?.close();
+    }
+  });
+}
+
+module.exports = { agentWebsocket };