@shakudo/opencode-mattermost-control 0.3.45

package/src/config.ts

@@ -0,0 +1,170 @@
+import { z } from "zod";
+import { log as fileLog } from "./logger.js";
+
+// Configuration schema
+const MattermostConfigSchema = z.object({
+  baseUrl: z.string().url(),
+  wsUrl: z.string(),
+  token: z.string().default(""),
+  botUsername: z.string().optional(),
+  defaultTeam: z.string().optional(),
+  debug: z.boolean().default(false),
+  reconnectInterval: z.number().default(5000),
+  maxReconnectAttempts: z.number().default(10),
+  autoConnect: z.boolean().default(true),
+  ownerUserId: z.string().optional(),
+});
+
+const StreamingConfigSchema = z.object({
+  bufferSize: z.number().default(50),
+  maxDelay: z.number().default(500),
+  editRateLimit: z.number().default(10),
+  maxPostLength: z.number().default(15000), // Mattermost limit is 16383, leave buffer for formatting
+});
+
+const NotificationsConfigSchema = z.object({
+  onCompletion: z.boolean().default(true),
+  onPermissionRequest: z.boolean().default(true),
+  onError: z.boolean().default(true),
+  onStatusUpdate: z.boolean().default(true),
+  statusInterval: z.number().default(30000),
+});
+
+const SessionsConfigSchema = z.object({
+  timeout: z.number().default(3600000),
+  maxSessions: z.number().default(50),
+  allowedUsers: z.array(z.string()).default([]),
+  allowedChannelTypes: z.array(z.enum(["D", "G", "O", "P"])).default(["D", "G", "O", "P"]),
+});
+
+const SessionSelectionConfigSchema = z.object({
+  commandPrefix: z.string().default("!"),
+  autoSelectSingle: z.boolean().default(true),
+  refreshIntervalMs: z.number().default(60000),
+  autoCreateSession: z.boolean().default(true),
+});
+
+const FilesConfigSchema = z.object({
+  tempDir: z.string().default("/tmp/opencode-mm-plugin"),
+  maxFileSize: z.number().default(10485760), // 10MB
+  allowedExtensions: z.array(z.string()).default(["*"]),
+});
+
+const PluginConfigSchema = z.object({
+  mattermost: MattermostConfigSchema,
+  streaming: StreamingConfigSchema,
+  notifications: NotificationsConfigSchema,
+  sessions: SessionsConfigSchema,
+  files: FilesConfigSchema,
+  sessionSelection: SessionSelectionConfigSchema,
+});
+
+export type MattermostConfig = z.infer<typeof MattermostConfigSchema>;
+export type StreamingConfig = z.infer<typeof StreamingConfigSchema>;
+export type NotificationsConfig = z.infer<typeof NotificationsConfigSchema>;
+export type SessionsConfig = z.infer<typeof SessionsConfigSchema>;
+export type FilesConfig = z.infer<typeof FilesConfigSchema>;
+export type SessionSelectionConfig = z.infer<typeof SessionSelectionConfigSchema>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
+
+// Default Mattermost configuration
+// NOTE: These are example URLs - you must configure your own Mattermost instance
+const DEFAULT_MATTERMOST_CONFIG = {
+  baseUrl: "https://your-mattermost-instance.example.com/api/v4",
+  wsUrl: "wss://your-mattermost-instance.example.com/api/v4/websocket",
+  token: "", // REQUIRED: Set via MATTERMOST_TOKEN environment variable
+  defaultTeam: "",
+  debug: false,
+  reconnectInterval: 5000,
+  maxReconnectAttempts: 10,
+};
+
+/**
+ * Load configuration from environment variables
+ */
+export function loadConfig(): PluginConfig {
+  // Get baseUrl and ensure it has /api/v4 suffix
+  let baseUrl = process.env.MATTERMOST_URL || DEFAULT_MATTERMOST_CONFIG.baseUrl;
+  if (!baseUrl.includes("/api/v4")) {
+    baseUrl = baseUrl.replace(/\/$/, "") + "/api/v4";
+  }
+
+  // Get wsUrl and ensure it has /api/v4/websocket suffix
+  let wsUrl = process.env.MATTERMOST_WS_URL || DEFAULT_MATTERMOST_CONFIG.wsUrl;
+  if (!wsUrl.includes("/api/v4/websocket")) {
+    wsUrl = wsUrl.replace(/\/$/, "").replace(/\/websocket$/, "");
+    wsUrl = wsUrl + "/api/v4/websocket";
+  }
+
+  const token = process.env.MATTERMOST_TOKEN || DEFAULT_MATTERMOST_CONFIG.token;
+
+  const config: PluginConfig = {
+    mattermost: {
+      baseUrl,
+      wsUrl,
+      token,
+      botUsername: process.env.MATTERMOST_BOT_USERNAME,
+      defaultTeam: process.env.MATTERMOST_TEAM || DEFAULT_MATTERMOST_CONFIG.defaultTeam,
+      debug: process.env.MATTERMOST_DEBUG === "true" || DEFAULT_MATTERMOST_CONFIG.debug,
+      reconnectInterval:
+        parseInt(process.env.MATTERMOST_RECONNECT_INTERVAL || "") ||
+        DEFAULT_MATTERMOST_CONFIG.reconnectInterval,
+      maxReconnectAttempts:
+        parseInt(process.env.MATTERMOST_MAX_RECONNECT_ATTEMPTS || "") ||
+        DEFAULT_MATTERMOST_CONFIG.maxReconnectAttempts,
+      autoConnect: process.env.MATTERMOST_AUTO_CONNECT !== "false",
+      ownerUserId: process.env.MATTERMOST_OWNER_USER_ID || undefined,
+    },
+    streaming: {
+      bufferSize: parseInt(process.env.OPENCODE_MM_BUFFER_SIZE || "") || 50,
+      maxDelay: parseInt(process.env.OPENCODE_MM_MAX_DELAY || "") || 500,
+      editRateLimit: parseInt(process.env.OPENCODE_MM_EDIT_RATE_LIMIT || "") || 10,
+      maxPostLength: parseInt(process.env.OPENCODE_MM_MAX_POST_LENGTH || "") || 15000,
+    },
+    notifications: {
+      onCompletion: process.env.OPENCODE_MM_NOTIFY_COMPLETION !== "false",
+      onPermissionRequest: process.env.OPENCODE_MM_NOTIFY_PERMISSION !== "false",
+      onError: process.env.OPENCODE_MM_NOTIFY_ERROR !== "false",
+      onStatusUpdate: process.env.OPENCODE_MM_NOTIFY_STATUS !== "false",
+      statusInterval: parseInt(process.env.OPENCODE_MM_STATUS_INTERVAL || "") || 30000,
+    },
+    sessions: {
+      timeout: parseInt(process.env.OPENCODE_MM_SESSION_TIMEOUT || "") || 3600000,
+      maxSessions: parseInt(process.env.OPENCODE_MM_MAX_SESSIONS || "") || 50,
+      allowedUsers: process.env.OPENCODE_MM_ALLOWED_USERS?.split(",").filter(Boolean) || [],
+      allowedChannelTypes: (process.env.OPENCODE_MM_ALLOWED_CHANNEL_TYPES?.split(",").filter(Boolean) as ("D" | "G" | "O" | "P")[]) || ["D", "G", "O", "P"],
+    },
+    files: {
+      tempDir: process.env.OPENCODE_MM_TEMP_DIR || "/tmp/opencode-mm-plugin",
+      maxFileSize: parseInt(process.env.OPENCODE_MM_MAX_FILE_SIZE || "") || 10485760,
+      allowedExtensions:
+        process.env.OPENCODE_MM_ALLOWED_EXTENSIONS?.split(",").filter(Boolean) || ["*"],
+    },
+    sessionSelection: {
+      commandPrefix: process.env.OPENCODE_MM_COMMAND_PREFIX || "!",
+      autoSelectSingle: process.env.OPENCODE_MM_AUTO_SELECT !== "false",
+      refreshIntervalMs: parseInt(process.env.OPENCODE_MM_SESSION_REFRESH_INTERVAL || "") || 60000,
+      autoCreateSession: process.env.OPENCODE_MM_AUTO_CREATE_SESSION !== "false",
+    },
+  };
+
+  // Validate configuration
+  return PluginConfigSchema.parse(config);
+}
+
+export function createLogger(debug: boolean) {
+  return {
+    debug: (...args: unknown[]) => {
+      if (debug) fileLog.debug(args.map(a => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" "));
+    },
+    info: (...args: unknown[]) => {
+      fileLog.info(args.map(a => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" "));
+    },
+    warn: (...args: unknown[]) => {
+      fileLog.warn(args.map(a => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" "));
+    },
+    error: (...args: unknown[]) => {
+      fileLog.error(args.map(a => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" "));
+    },
+  };
+}

package/src/context-builder.ts

@@ -0,0 +1,309 @@
+/**
+ * Context Builder for Group DM Thread Messages
+ * 
+ * Fetches recent thread messages and optionally summarizes them with Claude Haiku
+ * to provide context when responding to @mentions in group DMs.
+ */
+
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import type { Post, PostList } from "./models/index.js";
+import { log } from "./logger.js";
+
+/** Maximum context length in characters before summarization */
+const MAX_CONTEXT_LENGTH = 8000;
+
+/** Default number of messages to fetch from thread */
+const DEFAULT_MESSAGE_COUNT = 5;
+
+export interface ThreadMessage {
+  userId: string;
+  username: string;
+  message: string;
+  timestamp: number;
+  fileIds?: string[];
+}
+
+export interface ThreadContext {
+  messages: ThreadMessage[];
+  totalCharacters: number;
+  wasSummarized: boolean;
+  summary?: string;
+  allFileIds: string[];
+}
+
+/**
+ * Build context from recent thread messages, excluding bot messages
+ * 
+ * @param mmClient - Mattermost client instance
+ * @param threadRootPostId - Root post ID of the thread
+ * @param currentPostId - Current post ID (to exclude from context)
+ * @param botUserId - Bot user ID (to exclude bot messages)
+ * @param maxMessages - Maximum number of messages to fetch (default: 5)
+ * @returns ThreadContext with recent messages
+ */
+export async function buildThreadContext(
+  mmClient: MattermostClient,
+  threadRootPostId: string,
+  currentPostId: string,
+  botUserId: string,
+  maxMessages: number = DEFAULT_MESSAGE_COUNT
+): Promise<ThreadContext> {
+  try {
+    log.info(`[ContextBuilder] Fetching thread context for root post: ${threadRootPostId}`);
+    
+    // Fetch the full thread
+    const postList: PostList = await mmClient.getPostThread(threadRootPostId);
+    
+    if (!postList.order || postList.order.length === 0) {
+      log.info(`[ContextBuilder] No posts found in thread`);
+      return { messages: [], totalCharacters: 0, wasSummarized: false, allFileIds: [] };
+    }
+    
+    // Sort posts by create_at (oldest first), then take the most recent ones
+    const sortedPostIds = [...postList.order].sort((a, b) => {
+      const postA = postList.posts[a];
+      const postB = postList.posts[b];
+      return (postA?.create_at || 0) - (postB?.create_at || 0);
+    });
+    
+    // Filter out:
+    // 1. Bot messages
+    // 2. The current post (the @mention we're responding to)
+    // 3. The root post ONLY if it's a bot message (session announcement)
+    //    - If root is a user message (existing thread), include it for context
+    const relevantPosts: Post[] = sortedPostIds
+      .map(id => postList.posts[id])
+      .filter((post): post is Post => {
+        if (!post) return false;
+        if (post.user_id === botUserId) return false;
+        if (post.id === currentPostId) return false;
+        // Only exclude root post if it's from the bot (session announcement)
+        // User-created threads should have their root post included for context
+        if (post.id === threadRootPostId && post.user_id === botUserId) return false;
+        return true;
+      });
+    
+    // Take the last N messages
+    const recentPosts = relevantPosts.slice(-maxMessages);
+    
+    log.info(`[ContextBuilder] Found ${relevantPosts.length} relevant posts, using last ${recentPosts.length}`);
+    
+    // Build thread messages - we need to fetch usernames
+    const messages: ThreadMessage[] = [];
+    const userCache: Record<string, string> = {};
+    
+    for (const post of recentPosts) {
+      let username = userCache[post.user_id];
+      if (!username) {
+        try {
+          const user = await mmClient.getUserById(post.user_id);
+          username = user.username;
+          userCache[post.user_id] = username;
+        } catch (err) {
+          username = "unknown";
+          log.warn(`[ContextBuilder] Failed to fetch username for user ${post.user_id}`);
+        }
+      }
+      
+      const fileIds = post.file_ids && post.file_ids.length > 0 ? post.file_ids : undefined;
+      
+      messages.push({
+        userId: post.user_id,
+        username,
+        message: post.message,
+        timestamp: post.create_at,
+        fileIds,
+      });
+    }
+    
+    const totalCharacters = messages.reduce((sum, m) => sum + m.message.length, 0);
+    const allFileIds = messages.flatMap(m => m.fileIds || []);
+    
+    log.info(`[ContextBuilder] Built context with ${messages.length} messages, ${totalCharacters} chars, ${allFileIds.length} files`);
+    
+    return {
+      messages,
+      totalCharacters,
+      wasSummarized: false,
+      allFileIds,
+    };
+  } catch (error) {
+    log.error(`[ContextBuilder] Error building thread context: ${error}`);
+    return { messages: [], totalCharacters: 0, wasSummarized: false, allFileIds: [] };
+  }
+}
+
+/**
+ * Summarize context using Claude Haiku if it exceeds the character limit
+ * 
+ * @param client - OpenCode SDK client
+ * @param sessionId - OpenCode session ID to use for summarization
+ * @param context - Thread context to potentially summarize
+ * @returns Updated ThreadContext with summary if needed
+ */
+export async function summarizeContextWithHaiku(
+  client: any, // OpenCode SDK client
+  sessionId: string,
+  context: ThreadContext
+): Promise<ThreadContext> {
+  // Don't summarize if under the limit or no messages
+  if (context.totalCharacters <= MAX_CONTEXT_LENGTH || context.messages.length === 0) {
+    return context;
+  }
+  
+  log.info(`[ContextBuilder] Context exceeds ${MAX_CONTEXT_LENGTH} chars (${context.totalCharacters}), summarizing with Haiku`);
+  
+  try {
+    // Format messages for summarization
+    const conversationText = context.messages
+      .map(m => `@${m.username}: ${m.message}`)
+      .join("\n\n");
+    
+    const summaryPrompt = `Summarize the following conversation concisely, preserving key context, decisions, and any important details that would be needed to understand and respond to a follow-up message. Keep your summary under 500 words.
+
+Conversation:
+${conversationText}
+
+Summary:`;
+    
+    // Use Haiku for fast, cheap summarization
+    const result = await client.session.prompt({
+      sessionId,
+      prompt: summaryPrompt,
+      model: {
+        providerID: "anthropic",
+        modelID: "claude-3-5-haiku-20241022",
+      },
+    });
+    
+    // Extract text from result
+    let summary = "";
+    if (result && typeof result === "object" && "text" in result) {
+      summary = String(result.text);
+    } else if (typeof result === "string") {
+      summary = result;
+    }
+    
+    if (summary) {
+      log.info(`[ContextBuilder] Generated summary: ${summary.length} chars`);
+      return {
+        ...context,
+        wasSummarized: true,
+        summary,
+      };
+    }
+    
+    log.warn(`[ContextBuilder] Haiku returned empty summary, using original context`);
+    return context;
+  } catch (error) {
+    log.error(`[ContextBuilder] Error summarizing with Haiku: ${error}`);
+    // Fall back to original context on error
+    return context;
+  }
+}
+
+/**
+ * Format context as a prefix for the user's prompt
+ * 
+ * @param context - Thread context (possibly summarized)
+ * @param currentUsername - Username of the person who @mentioned the bot
+ * @returns Formatted context prefix string, or empty string if no context
+ */
+export function formatContextForPrompt(
+  context: ThreadContext,
+  currentUsername: string
+): string {
+  if (context.messages.length === 0 && !context.summary) {
+    return "";
+  }
+  
+  let contextBlock: string;
+  
+  if (context.wasSummarized && context.summary) {
+    contextBlock = `[Previous conversation summary]
+${context.summary}`;
+    if (context.allFileIds.length > 0) {
+      contextBlock += `\n[Note: ${context.allFileIds.length} file attachment(s) from this conversation are included below]`;
+    }
+  } else {
+    const formattedMessages = context.messages
+      .map(m => {
+        let text = `@${m.username}: ${m.message}`;
+        if (m.fileIds && m.fileIds.length > 0) {
+          text += ` [${m.fileIds.length} attachment(s)]`;
+        }
+        return text;
+      })
+      .join("\n\n");
+    
+    contextBlock = `[Previous messages in this thread]
+${formattedMessages}`;
+  }
+  
+  return `${contextBlock}
+
+[Current message from @${currentUsername}]
+`;
+}
+
+/**
+ * Check if a message contains a bot @mention
+ * 
+ * @param message - Message text to check
+ * @param botUsername - Bot username (without @)
+ * @param botUserId - Bot user ID
+ * @returns true if the bot is mentioned
+ */
+export function isBotMentioned(
+  message: string,
+  botUsername: string,
+  botUserId: string
+): boolean {
+  // Check for @username mention (case-insensitive)
+  const atMentionRegex = new RegExp(`@${escapeRegExp(botUsername)}\\b`, "i");
+  if (atMentionRegex.test(message)) {
+    return true;
+  }
+  
+  // Check for user ID mention format used by some Mattermost clients
+  if (message.includes(`<@${botUserId}>`)) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Strip bot @mentions from a message to clean up the prompt
+ * 
+ * @param message - Message text
+ * @param botUsername - Bot username (without @)
+ * @param botUserId - Bot user ID
+ * @returns Message with bot mentions removed
+ */
+export function stripBotMention(
+  message: string,
+  botUsername: string,
+  botUserId: string
+): string {
+  // Remove @username mentions (case-insensitive)
+  let cleaned = message.replace(
+    new RegExp(`@${escapeRegExp(botUsername)}\\b`, "gi"),
+    ""
+  );
+  
+  // Remove user ID mention format
+  cleaned = cleaned.replace(new RegExp(`<@${escapeRegExp(botUserId)}>`, "g"), "");
+  
+  // Clean up extra whitespace
+  cleaned = cleaned.replace(/\s+/g, " ").trim();
+  
+  return cleaned;
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}