opensentinel 2.1.1

package/dist/chunk-L3PDU3XN.js

@@ -0,0 +1,803 @@
+import {
+  transcribeAudio
+} from "./chunk-GVJVEWHI.js";
+import {
+  scheduleReminder
+} from "./chunk-4LVWXUNC.js";
+import {
+  chatWithTools
+} from "./chunk-CI6Q63MM.js";
+
+// src/inputs/slack/index.ts
+import { createRequire } from "module";
+
+// src/inputs/slack/commands.ts
+var sessions = /* @__PURE__ */ new Map();
+var MAX_HISTORY = 20;
+function getSession(userId) {
+  if (!sessions.has(userId)) {
+    sessions.set(userId, []);
+  }
+  return sessions.get(userId);
+}
+function addToSession(userId, message) {
+  const session = getSession(userId);
+  session.push(message);
+  if (session.length > MAX_HISTORY) {
+    sessions.set(userId, session.slice(-MAX_HISTORY));
+  }
+}
+function clearSession(userId) {
+  sessions.set(userId, []);
+}
+var askCommand = {
+  command: "/opensentinel-ask",
+  description: "Ask OpenSentinel a question",
+  usage: "/opensentinel-ask <question>",
+  async handler({ command, ack, respond, client }) {
+    await ack();
+    const question = command.text.trim();
+    const userId = command.user_id;
+    if (!question) {
+      await respond({
+        response_type: "ephemeral",
+        text: "Please provide a question. Usage: `/opensentinel-ask <question>`"
+      });
+      return;
+    }
+    try {
+      addToSession(userId, { role: "user", content: question });
+      const response = await chatWithTools(
+        getSession(userId),
+        `slack:${userId}`
+      );
+      addToSession(userId, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `_Used: ${toolList}_
+
+${response.content}`;
+      }
+      await respond({
+        response_type: "in_channel",
+        text: finalResponse,
+        mrkdwn: true
+      });
+      console.log(
+        `[Slack] Processed /opensentinel-ask from ${userId}. Tokens: ${response.inputTokens}/${response.outputTokens}`
+      );
+    } catch (error) {
+      console.error("[Slack] Error processing /opensentinel-ask:", error);
+      await respond({
+        response_type: "ephemeral",
+        text: "Sorry, I encountered an error processing your question. Please try again."
+      });
+    }
+  }
+};
+var chatCommand = {
+  command: "/opensentinel-chat",
+  description: "Continue a conversation with OpenSentinel",
+  usage: "/opensentinel-chat <message>",
+  async handler({ command, ack, respond }) {
+    await ack();
+    const message = command.text.trim();
+    const userId = command.user_id;
+    if (!message) {
+      await respond({
+        response_type: "ephemeral",
+        text: "Please provide a message. Usage: `/opensentinel-chat <message>`"
+      });
+      return;
+    }
+    try {
+      addToSession(userId, { role: "user", content: message });
+      const response = await chatWithTools(
+        getSession(userId),
+        `slack:${userId}`
+      );
+      addToSession(userId, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `_Used: ${toolList}_
+
+${response.content}`;
+      }
+      await respond({
+        response_type: "in_channel",
+        text: finalResponse,
+        mrkdwn: true
+      });
+      console.log(
+        `[Slack] Processed /opensentinel-chat from ${userId}. Tokens: ${response.inputTokens}/${response.outputTokens}`
+      );
+    } catch (error) {
+      console.error("[Slack] Error processing /opensentinel-chat:", error);
+      await respond({
+        response_type: "ephemeral",
+        text: "Sorry, I encountered an error processing your message. Please try again."
+      });
+    }
+  }
+};
+var clearCommand = {
+  command: "/opensentinel-clear",
+  description: "Clear your conversation history with OpenSentinel",
+  usage: "/opensentinel-clear",
+  async handler({ command, ack, respond }) {
+    await ack();
+    clearSession(command.user_id);
+    await respond({
+      response_type: "ephemeral",
+      text: "Conversation history cleared."
+    });
+    console.log(`[Slack] Cleared history for ${command.user_id}`);
+  }
+};
+var remindCommand = {
+  command: "/opensentinel-remind",
+  description: "Set a reminder",
+  usage: "/opensentinel-remind <time><s/m/h> <message>",
+  async handler({ command, ack, respond }) {
+    await ack();
+    const text = command.text.trim();
+    const match = text.match(/^(\d+)(s|m|h)\s+(.+)$/i);
+    if (!match) {
+      await respond({
+        response_type: "ephemeral",
+        text: "Invalid format. Use: `/opensentinel-remind <number><s/m/h> <message>`\n\nExamples:\n\u2022 `/opensentinel-remind 5m Check the oven`\n\u2022 `/opensentinel-remind 1h Call mom`\n\u2022 `/opensentinel-remind 30s Test reminder`"
+      });
+      return;
+    }
+    const [, amount, unit, message] = match;
+    const multipliers = {
+      s: 1e3,
+      m: 60 * 1e3,
+      h: 60 * 60 * 1e3
+    };
+    const delayMs = parseInt(amount) * multipliers[unit.toLowerCase()];
+    try {
+      await scheduleReminder(
+        message,
+        delayMs,
+        `slack:${command.channel_id}:${command.user_id}`
+      );
+      const timeStr = unit === "s" ? "seconds" : unit === "m" ? "minutes" : "hours";
+      await respond({
+        response_type: "ephemeral",
+        text: `Reminder set for ${amount} ${timeStr}: "${message}"`
+      });
+      console.log(
+        `[Slack] Reminder set by ${command.user_id}: ${amount}${unit} - "${message}"`
+      );
+    } catch (error) {
+      console.error("[Slack] Error setting reminder:", error);
+      await respond({
+        response_type: "ephemeral",
+        text: "Sorry, I couldn't set the reminder. Please try again."
+      });
+    }
+  }
+};
+var statusCommand = {
+  command: "/opensentinel-status",
+  description: "Check OpenSentinel status and capabilities",
+  usage: "/opensentinel-status",
+  async handler({ command, ack, respond }) {
+    await ack();
+    const session = getSession(command.user_id);
+    const historyCount = session.length;
+    await respond({
+      response_type: "ephemeral",
+      text: `*OpenSentinel Status*
+
+Bot: Online
+Your conversation history: ${historyCount} messages
+
+*Capabilities:*
+\u2022 Chat and answer questions using Claude AI
+\u2022 Execute shell commands
+\u2022 Read and write files
+\u2022 Search the web
+\u2022 Remember important information
+\u2022 Set reminders
+
+Use \`/opensentinel-help\` for available commands.`
+    });
+  }
+};
+var helpCommand = {
+  command: "/opensentinel-help",
+  description: "Show available OpenSentinel commands",
+  usage: "/opensentinel-help",
+  async handler({ ack, respond }) {
+    await ack();
+    await respond({
+      response_type: "ephemeral",
+      text: "*OpenSentinel Commands*\n\n`/opensentinel-ask <question>` - Ask a single question\n`/opensentinel-chat <message>` - Continue a conversation\n`/opensentinel-clear` - Clear your conversation history\n`/opensentinel-remind <time> <message>` - Set a reminder\n`/opensentinel-status` - Check bot status\n`/opensentinel-help` - Show this help message\n\n*Tips:*\n\u2022 Use `/opensentinel-chat` for multi-turn conversations with context\n\u2022 Use `/opensentinel-ask` for quick one-off questions\n\u2022 Mention @OpenSentinel in any channel to chat directly\n\u2022 DM the bot for private conversations"
+    });
+  }
+};
+var mainCommand = {
+  command: "/opensentinel",
+  description: "OpenSentinel AI assistant",
+  usage: "/opensentinel <ask|chat|clear|remind|status|help> [args]",
+  async handler({ command, ack, respond }) {
+    await ack();
+    const [subcommand, ...args] = command.text.trim().split(/\s+/);
+    const argsText = args.join(" ");
+    switch (subcommand?.toLowerCase()) {
+      case "ask":
+        if (!argsText) {
+          await respond({
+            response_type: "ephemeral",
+            text: "Please provide a question. Usage: `/opensentinel ask <question>`"
+          });
+          return;
+        }
+        command.text = argsText;
+        await askCommand.handler({ command, ack, respond });
+        break;
+      case "chat":
+        if (!argsText) {
+          await respond({
+            response_type: "ephemeral",
+            text: "Please provide a message. Usage: `/opensentinel chat <message>`"
+          });
+          return;
+        }
+        command.text = argsText;
+        await chatCommand.handler({ command, ack, respond });
+        break;
+      case "clear":
+        await clearCommand.handler({ command, ack, respond });
+        break;
+      case "remind":
+        command.text = argsText;
+        await remindCommand.handler({ command, ack, respond });
+        break;
+      case "status":
+        await statusCommand.handler({ command, ack, respond });
+        break;
+      case "help":
+      default:
+        await respond({
+          response_type: "ephemeral",
+          text: "*OpenSentinel Commands*\n\n`/opensentinel ask <question>` - Ask a single question\n`/opensentinel chat <message>` - Continue a conversation\n`/opensentinel clear` - Clear your conversation history\n`/opensentinel remind <time> <message>` - Set a reminder\n`/opensentinel status` - Check bot status\n`/opensentinel help` - Show this help message\n\n*Or use individual commands:*\n`/opensentinel-ask`, `/opensentinel-chat`, `/opensentinel-clear`, `/opensentinel-remind`, `/opensentinel-status`, `/opensentinel-help`"
+        });
+        break;
+    }
+  }
+};
+var slashCommands = [
+  mainCommand,
+  askCommand,
+  chatCommand,
+  clearCommand,
+  remindCommand,
+  statusCommand,
+  helpCommand
+];
+function getCommand(name) {
+  return slashCommands.find((cmd) => cmd.command === name);
+}
+function getCommandNames() {
+  return slashCommands.map((cmd) => cmd.command);
+}
+function splitMessage(text, maxLength = 3e3) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let breakPoint = remaining.lastIndexOf("\n", maxLength);
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = remaining.lastIndexOf(" ", maxLength);
+    }
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = maxLength;
+    }
+    chunks.push(remaining.slice(0, breakPoint));
+    remaining = remaining.slice(breakPoint).trim();
+  }
+  return chunks;
+}
+function formatAsBlocks(text) {
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text
+      }
+    }
+  ];
+}
+function createErrorBlocks(message) {
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `:warning: *Error*
+${message}`
+      }
+    }
+  ];
+}
+function createSuccessBlocks(message) {
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `:white_check_mark: ${message}`
+      }
+    }
+  ];
+}
+
+// src/inputs/slack/index.ts
+var require2 = createRequire(import.meta.url);
+var { App, ExpressReceiver } = require2("@slack/bolt");
+var { WebClient } = require2("@slack/web-api");
+var SlackBot = class {
+  app;
+  config;
+  client;
+  receiver;
+  isRunning = false;
+  constructor(config) {
+    this.config = {
+      allowDMs: true,
+      allowMentions: true,
+      allowThreadReplies: true,
+      ...config
+    };
+    if (!config.socketMode) {
+      this.receiver = new ExpressReceiver({
+        signingSecret: config.signingSecret
+      });
+    }
+    this.app = new App({
+      token: config.token,
+      signingSecret: config.signingSecret,
+      socketMode: config.socketMode,
+      appToken: config.appToken,
+      receiver: this.receiver
+    });
+    this.client = new WebClient(config.token);
+    this.setupEventHandlers();
+    this.setupSlashCommands();
+  }
+  /**
+   * Set up Slack event handlers
+   */
+  setupEventHandlers() {
+    if (this.config.allowMentions) {
+      this.app.event("app_mention", async (args) => {
+        await this.handleAppMention(args);
+      });
+    }
+    if (this.config.allowDMs) {
+      this.app.message(async (args) => {
+        await this.handleMessage(args);
+      });
+    }
+    this.app.event("file_shared", async (args) => {
+      await this.handleFileShared(args);
+    });
+    this.app.error(async (error) => {
+      console.error("[Slack] App error:", error);
+    });
+  }
+  /**
+   * Set up slash command handlers
+   */
+  setupSlashCommands() {
+    for (const cmd of slashCommands) {
+      this.app.command(cmd.command, async (args) => {
+        if (!this.isUserAuthorized(args.command.user_id, args.command.channel_id)) {
+          await args.ack();
+          await args.respond({
+            response_type: "ephemeral",
+            text: "You are not authorized to use this bot."
+          });
+          return;
+        }
+        await cmd.handler(args);
+      });
+    }
+  }
+  /**
+   * Handle app mentions
+   */
+  async handleAppMention(args) {
+    const { event, say, client } = args;
+    if (!this.isUserAuthorized(event.user, event.channel)) {
+      return;
+    }
+    const text = event.text.replace(/<@[A-Z0-9]+>/gi, "").trim();
+    if (!text) {
+      await say({
+        text: "Hi! How can I help you? Mention me with a question or use `/sentinel help` for available commands.",
+        thread_ts: event.thread_ts || event.ts
+      });
+      return;
+    }
+    const userId = event.user;
+    const sessionKey = event.thread_ts ? `${userId}:thread:${event.thread_ts}` : userId;
+    try {
+      await client.reactions.add({
+        channel: event.channel,
+        timestamp: event.ts,
+        name: "hourglass_flowing_sand"
+      });
+      addToSession(sessionKey, { role: "user", content: text });
+      const response = await chatWithTools(
+        getSession(sessionKey),
+        `slack:${userId}`
+      );
+      addToSession(sessionKey, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `_Used: ${toolList}_
+
+${response.content}`;
+      }
+      try {
+        await client.reactions.remove({
+          channel: event.channel,
+          timestamp: event.ts,
+          name: "hourglass_flowing_sand"
+        });
+      } catch {
+      }
+      if (finalResponse.length > 3e3) {
+        const chunks = splitMessage(finalResponse, 3e3);
+        for (const chunk of chunks) {
+          await say({
+            text: chunk,
+            thread_ts: event.thread_ts || event.ts,
+            mrkdwn: true
+          });
+        }
+      } else {
+        await say({
+          text: finalResponse,
+          thread_ts: event.thread_ts || event.ts,
+          mrkdwn: true
+        });
+      }
+      console.log(
+        `[Slack] Processed mention from ${userId}. Tokens: ${response.inputTokens}/${response.outputTokens}` + (response.toolsUsed ? ` Tools: ${response.toolsUsed.join(", ")}` : "")
+      );
+    } catch (error) {
+      console.error("[Slack] Error processing mention:", error);
+      try {
+        await client.reactions.remove({
+          channel: event.channel,
+          timestamp: event.ts,
+          name: "hourglass_flowing_sand"
+        });
+        await client.reactions.add({
+          channel: event.channel,
+          timestamp: event.ts,
+          name: "x"
+        });
+      } catch {
+      }
+      await say({
+        text: "Sorry, I encountered an error processing your message. Please try again.",
+        thread_ts: event.thread_ts || event.ts
+      });
+    }
+  }
+  /**
+   * Handle direct messages
+   */
+  async handleMessage(args) {
+    const { event, say, client, message } = args;
+    const genericMessage = message;
+    if (genericMessage.subtype) return;
+    if ("bot_id" in event) return;
+    const channelType = event.channel_type;
+    if (channelType !== "im" && channelType !== "mpim") return;
+    const userId = message.user;
+    if (!userId) return;
+    if (!this.isUserAuthorized(userId, event.channel)) {
+      return;
+    }
+    const text = message.text || "";
+    if (!text.trim()) return;
+    const threadedMessage = message;
+    const sessionKey = threadedMessage.thread_ts ? `${userId}:thread:${threadedMessage.thread_ts}` : userId;
+    try {
+      await client.reactions.add({
+        channel: event.channel,
+        timestamp: message.ts,
+        name: "hourglass_flowing_sand"
+      });
+      addToSession(sessionKey, { role: "user", content: text });
+      const response = await chatWithTools(
+        getSession(sessionKey),
+        `slack:${userId}`
+      );
+      addToSession(sessionKey, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `_Used: ${toolList}_
+
+${response.content}`;
+      }
+      try {
+        await client.reactions.remove({
+          channel: event.channel,
+          timestamp: message.ts,
+          name: "hourglass_flowing_sand"
+        });
+      } catch {
+      }
+      const replyTs = this.config.allowThreadReplies && threadedMessage.thread_ts ? threadedMessage.thread_ts : void 0;
+      if (finalResponse.length > 3e3) {
+        const chunks = splitMessage(finalResponse, 3e3);
+        for (const chunk of chunks) {
+          await say({
+            text: chunk,
+            thread_ts: replyTs,
+            mrkdwn: true
+          });
+        }
+      } else {
+        await say({
+          text: finalResponse,
+          thread_ts: replyTs,
+          mrkdwn: true
+        });
+      }
+      console.log(
+        `[Slack] Processed DM from ${userId}. Tokens: ${response.inputTokens}/${response.outputTokens}` + (response.toolsUsed ? ` Tools: ${response.toolsUsed.join(", ")}` : "")
+      );
+    } catch (error) {
+      console.error("[Slack] Error processing message:", error);
+      try {
+        await client.reactions.remove({
+          channel: event.channel,
+          timestamp: message.ts,
+          name: "hourglass_flowing_sand"
+        });
+        await client.reactions.add({
+          channel: event.channel,
+          timestamp: message.ts,
+          name: "x"
+        });
+      } catch {
+      }
+      await say({
+        text: "Sorry, I encountered an error processing your message. Please try again."
+      });
+    }
+  }
+  /**
+   * Handle file shared events
+   */
+  async handleFileShared(args) {
+    const { event, client } = args;
+    try {
+      const fileInfo = await client.files.info({ file: event.file_id });
+      const file = fileInfo.file;
+      if (!file) return;
+      const mimetype = file.mimetype || "";
+      if (mimetype.startsWith("audio/")) {
+        if (file.url_private_download) {
+          const response = await fetch(file.url_private_download, {
+            headers: {
+              Authorization: `Bearer ${this.config.token}`
+            }
+          });
+          if (response.ok) {
+            const audioBuffer = await response.arrayBuffer();
+            const transcription = await transcribeAudio(Buffer.from(audioBuffer));
+            if (transcription) {
+              const channelId = file.channels && file.channels[0] || file.ims && file.ims[0];
+              if (channelId) {
+                await client.chat.postMessage({
+                  channel: channelId,
+                  text: `Audio transcription: "${transcription}"`,
+                  mrkdwn: true
+                });
+                console.log(
+                  `[Slack] Transcribed audio file: ${file.name}`
+                );
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error("[Slack] Error processing file:", error);
+    }
+  }
+  /**
+   * Check if a user is authorized to use the bot
+   */
+  isUserAuthorized(userId, channelId) {
+    if (!this.config.allowedUserIds?.length && !this.config.allowedChannelIds?.length) {
+      return true;
+    }
+    if (this.config.allowedUserIds?.includes(userId)) {
+      return true;
+    }
+    if (this.config.allowedChannelIds?.includes(channelId)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Start the Slack bot
+   */
+  async start() {
+    const port = this.config.port || 3e3;
+    console.log("[Slack] Starting bot...");
+    await this.app.start(port);
+    this.isRunning = true;
+    if (this.config.socketMode) {
+      console.log("[Slack] Bot started in Socket Mode");
+    } else {
+      console.log(`[Slack] Bot started on port ${port}`);
+    }
+  }
+  /**
+   * Stop the Slack bot
+   */
+  async stop() {
+    console.log("[Slack] Stopping bot...");
+    await this.app.stop();
+    this.isRunning = false;
+    console.log("[Slack] Bot stopped");
+  }
+  /**
+   * Get the Slack app instance
+   */
+  getApp() {
+    return this.app;
+  }
+  /**
+   * Get the Slack Web API client
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Check if bot is running
+   */
+  running() {
+    return this.isRunning;
+  }
+  /**
+   * Send a message to a channel
+   */
+  async sendMessage(channelId, text, options) {
+    return this.client.chat.postMessage({
+      channel: channelId,
+      text,
+      thread_ts: options?.threadTs,
+      mrkdwn: options?.mrkdwn ?? true,
+      blocks: options?.blocks
+    });
+  }
+  /**
+   * Send a message with blocks
+   */
+  async sendBlocks(channelId, blocks, text, threadTs) {
+    return this.client.chat.postMessage({
+      channel: channelId,
+      text: text || "Message",
+      blocks,
+      thread_ts: threadTs
+    });
+  }
+  /**
+   * Send a file to a channel
+   */
+  async sendFile(channelId, content, filename, options) {
+    await this.client.files.uploadV2({
+      channel_id: channelId,
+      file: content,
+      filename,
+      title: options?.title,
+      initial_comment: options?.initialComment,
+      thread_ts: options?.threadTs
+    });
+  }
+  /**
+   * Reply to a thread
+   */
+  async replyToThread(channelId, threadTs, text, mrkdwn) {
+    return this.client.chat.postMessage({
+      channel: channelId,
+      text,
+      thread_ts: threadTs,
+      mrkdwn: mrkdwn ?? true
+    });
+  }
+  /**
+   * Add a reaction to a message
+   */
+  async addReaction(channelId, timestamp, emoji) {
+    await this.client.reactions.add({
+      channel: channelId,
+      timestamp,
+      name: emoji
+    });
+  }
+  /**
+   * Remove a reaction from a message
+   */
+  async removeReaction(channelId, timestamp, emoji) {
+    await this.client.reactions.remove({
+      channel: channelId,
+      timestamp,
+      name: emoji
+    });
+  }
+  /**
+   * Get user info
+   */
+  async getUserInfo(userId) {
+    const result = await this.client.users.info({ user: userId });
+    return result.user;
+  }
+  /**
+   * Get channel info
+   */
+  async getChannelInfo(channelId) {
+    const result = await this.client.conversations.info({ channel: channelId });
+    return result.channel;
+  }
+  /**
+   * Get the Express receiver (for adding custom routes)
+   */
+  getReceiver() {
+    return this.receiver;
+  }
+};
+function createSlackBot(config) {
+  return new SlackBot(config);
+}
+var slack_default = {
+  createSlackBot,
+  SlackBot,
+  slashCommands
+};
+
+export {
+  sessions,
+  getSession,
+  addToSession,
+  clearSession,
+  askCommand,
+  chatCommand,
+  clearCommand,
+  remindCommand,
+  statusCommand,
+  helpCommand,
+  mainCommand,
+  slashCommands,
+  getCommand,
+  getCommandNames,
+  splitMessage,
+  formatAsBlocks,
+  createErrorBlocks,
+  createSuccessBlocks,
+  SlackBot,
+  createSlackBot,
+  slack_default
+};
+//# sourceMappingURL=chunk-L3PDU3XN.js.map