@shakudo/opencode-mattermost-control 0.3.45

package/src/file-handler.ts

@@ -0,0 +1,242 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { MattermostClient } from "./clients/mattermost-client.js";
+import type { FilesConfig } from "./config.js";
+import type { UserSession } from "./session-manager.js";
+import { log } from "./logger.js";
+
+export class FileHandler {
+  private mmClient: MattermostClient;
+  private config: FilesConfig;
+  private tempFiles: Set<string> = new Set();
+
+  constructor(mmClient: MattermostClient, config: FilesConfig) {
+    this.mmClient = mmClient;
+    this.config = config;
+    this.ensureTempDir();
+  }
+
+  private ensureTempDir(): void {
+    if (!fs.existsSync(this.config.tempDir)) {
+      fs.mkdirSync(this.config.tempDir, { recursive: true });
+    }
+  }
+
+  async processInboundAttachments(fileIds: string[]): Promise<string[]> {
+    const filePaths: string[] = [];
+
+    for (const fileId of fileIds) {
+      try {
+        const fileInfo = await this.mmClient.getFileInfo(fileId);
+
+        if (fileInfo.size > this.config.maxFileSize) {
+          log.warn(`[FileHandler] File ${fileInfo.name} exceeds max size, skipping`);
+          continue;
+        }
+
+        if (
+          this.config.allowedExtensions[0] !== "*" &&
+          !this.config.allowedExtensions.includes(fileInfo.extension)
+        ) {
+          log.warn(`[FileHandler] File extension ${fileInfo.extension} not allowed, skipping`);
+          continue;
+        }
+
+        const fileData = await this.mmClient.downloadFile(fileId);
+        const tempFileName = `${Date.now()}-${fileInfo.name}`;
+        const tempFilePath = path.join(this.config.tempDir, tempFileName);
+
+        fs.writeFileSync(tempFilePath, fileData);
+        this.tempFiles.add(tempFilePath);
+        filePaths.push(tempFilePath);
+
+        log.debug(`[FileHandler] Downloaded file: ${fileInfo.name} -> ${tempFilePath}`);
+      } catch (error) {
+        log.error(`[FileHandler] Failed to process file ${fileId}:`, error);
+      }
+    }
+
+    return filePaths;
+  }
+
+  async processInboundAttachmentsAsFileParts(fileIds: string[]): Promise<{
+    fileParts: Array<{ type: "file"; mime: string; filename: string; url: string }>;
+    textFilePaths: string[];
+  }> {
+    const fileParts: Array<{ type: "file"; mime: string; filename: string; url: string }> = [];
+    const textFilePaths: string[] = [];
+
+    for (const fileId of fileIds) {
+      try {
+        const fileInfo = await this.mmClient.getFileInfo(fileId);
+
+        if (fileInfo.size > this.config.maxFileSize) {
+          log.warn(`[FileHandler] File ${fileInfo.name} exceeds max size, skipping`);
+          continue;
+        }
+
+        if (
+          this.config.allowedExtensions[0] !== "*" &&
+          !this.config.allowedExtensions.includes(fileInfo.extension)
+        ) {
+          log.warn(`[FileHandler] File extension ${fileInfo.extension} not allowed, skipping`);
+          continue;
+        }
+
+        const fileData = await this.mmClient.downloadFile(fileId);
+        const tempFileName = `${Date.now()}-${fileInfo.name}`;
+        const tempFilePath = path.join(this.config.tempDir, tempFileName);
+
+        fs.writeFileSync(tempFilePath, fileData);
+        this.tempFiles.add(tempFilePath);
+
+        const mimeType = this.getMimeType(tempFilePath);
+
+        if (this.isImageOrPdf(mimeType)) {
+          const base64Data = fileData.toString("base64");
+          fileParts.push({
+            type: "file",
+            mime: mimeType,
+            filename: fileInfo.name,
+            url: `data:${mimeType};base64,${base64Data}`,
+          });
+          log.debug(`[FileHandler] Processed file as FilePart: ${fileInfo.name} (${mimeType})`);
+        } else {
+          textFilePaths.push(tempFilePath);
+          log.debug(`[FileHandler] Downloaded text file: ${fileInfo.name} -> ${tempFilePath}`);
+        }
+      } catch (error) {
+        log.error(`[FileHandler] Failed to process file ${fileId}:`, error);
+      }
+    }
+
+    return { fileParts, textFilePaths };
+  }
+
+  async sendOutboundFile(
+    session: UserSession,
+    filePath: string,
+    message?: string
+  ): Promise<void> {
+    try {
+      const fileName = path.basename(filePath);
+      const fileData = fs.readFileSync(filePath);
+      const mimeType = this.getMimeType(filePath);
+
+      const uploadResult = await this.mmClient.uploadFile(
+        session.dmChannelId,
+        fileName,
+        fileData,
+        mimeType
+      );
+
+      const fileIds = uploadResult.file_infos.map((f) => f.id);
+      const displayMessage = message || `File: \`${fileName}\``;
+
+      await this.mmClient.createPost(session.dmChannelId, displayMessage, undefined, fileIds);
+
+      log.debug(`[FileHandler] Sent file: ${fileName}`);
+    } catch (error) {
+      log.error(`[FileHandler] Failed to send file ${filePath}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Send a file to a specific Mattermost channel and thread.
+   * Used by the send_file_to_mattermost tool to post files in the correct conversation thread.
+   */
+  async sendFileToThread(
+    channelId: string,
+    threadRootPostId: string,
+    filePath: string,
+    message?: string
+  ): Promise<{ success: boolean; fileName: string; error?: string }> {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return { success: false, fileName: path.basename(filePath), error: `File not found: ${filePath}` };
+      }
+
+      const fileName = path.basename(filePath);
+      const fileData = fs.readFileSync(filePath);
+      const mimeType = this.getMimeType(filePath);
+      const fileSize = fileData.length;
+
+      if (fileSize > this.config.maxFileSize) {
+        return { 
+          success: false, 
+          fileName, 
+          error: `File exceeds maximum size (${(fileSize / 1024 / 1024).toFixed(2)}MB > ${(this.config.maxFileSize / 1024 / 1024).toFixed(2)}MB)` 
+        };
+      }
+
+      const uploadResult = await this.mmClient.uploadFile(
+        channelId,
+        fileName,
+        fileData,
+        mimeType
+      );
+
+      const fileIds = uploadResult.file_infos.map((f) => f.id);
+      const displayMessage = message || `File: \`${fileName}\``;
+
+      await this.mmClient.createPost(channelId, displayMessage, threadRootPostId, fileIds);
+
+      log.info(`[FileHandler] Sent file to thread: ${fileName} (${(fileSize / 1024).toFixed(1)}KB)`);
+      return { success: true, fileName };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log.error(`[FileHandler] Failed to send file to thread ${filePath}:`, error);
+      return { success: false, fileName: path.basename(filePath), error: errorMessage };
+    }
+  }
+
+  getMimeType(filePath: string): string {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes: Record<string, string> = {
+      ".txt": "text/plain",
+      ".md": "text/markdown",
+      ".json": "application/json",
+      ".js": "application/javascript",
+      ".ts": "application/typescript",
+      ".py": "text/x-python",
+      ".html": "text/html",
+      ".css": "text/css",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".pdf": "application/pdf",
+      ".zip": "application/zip",
+      ".csv": "text/csv",
+      ".xml": "application/xml",
+      ".yaml": "application/x-yaml",
+      ".yml": "application/x-yaml",
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+
+  isImageOrPdf(mimeType: string): boolean {
+    return mimeType.startsWith("image/") || mimeType === "application/pdf";
+  }
+
+  cleanupTempFiles(): void {
+    for (const filePath of this.tempFiles) {
+      try {
+        if (fs.existsSync(filePath)) {
+          fs.unlinkSync(filePath);
+          log.debug(`[FileHandler] Cleaned up temp file: ${filePath}`);
+        }
+      } catch (error) {
+        log.error(`[FileHandler] Failed to cleanup temp file ${filePath}:`, error);
+      }
+    }
+    this.tempFiles.clear();
+  }
+
+  cleanupSessionFiles(session: UserSession): void {
+    this.cleanupTempFiles();
+  }
+}

package/src/guest-approval-handler.ts

@@ -0,0 +1,223 @@
+import { log } from "./logger.js";
+import type { Post } from "./models/index.js";
+import type { ThreadMappingStore } from "./persistence/thread-mapping-store.js";
+import type { TeamStore } from "./persistence/team-store.js";
+
+export interface PendingApproval {
+  requestPostId: string;
+  guestUserId: string;
+  guestUsername: string;
+  originalPost: Post;
+  threadRootPostId: string;
+  sessionId: string;
+  createdAt: Date;
+}
+
+export class GuestApprovalHandler {
+  private mmClient: any;
+  private pendingApprovals: Map<string, PendingApproval> = new Map();
+  private readonly APPROVAL_TIMEOUT_MS = 30 * 60 * 1000;
+
+  constructor(mmClient: any) {
+    this.mmClient = mmClient;
+  }
+
+  async requestApproval(
+    post: Post,
+    guestUsername: string,
+    threadRootPostId: string,
+    sessionId: string,
+    channelId: string
+  ): Promise<string> {
+    const messagePreview = post.message.length > 200 
+      ? post.message.substring(0, 200) + "..." 
+      : post.message;
+
+    const approvalMessage = `🔔 **Guest Access Request**
+
+@${guestUsername} wants to send a prompt in this session:
+
+> ${messagePreview}
+
+**Reply with a number to respond:**
+\`1\` - Approve this message only
+\`2\` - Approve all future messages from @${guestUsername} in this thread
+\`3\` - Approve all users in this thread
+
+_Reply \`deny\` or \`0\` to reject_`;
+
+    const requestPost = await this.mmClient.createPost(
+      channelId,
+      approvalMessage,
+      threadRootPostId
+    );
+
+    const pending: PendingApproval = {
+      requestPostId: requestPost.id,
+      guestUserId: post.user_id,
+      guestUsername,
+      originalPost: post,
+      threadRootPostId,
+      sessionId,
+      createdAt: new Date(),
+    };
+
+    this.pendingApprovals.set(sessionId, pending);
+    log.info(`[GuestApproval] Requested approval for @${guestUsername} in session ${sessionId.substring(0, 8)}`);
+
+    return requestPost.id;
+  }
+
+  hasPendingApproval(sessionId: string): boolean {
+    const pending = this.pendingApprovals.get(sessionId);
+    if (!pending) return false;
+
+    const elapsed = Date.now() - pending.createdAt.getTime();
+    if (elapsed > this.APPROVAL_TIMEOUT_MS) {
+      this.pendingApprovals.delete(sessionId);
+      log.info(`[GuestApproval] Approval request expired for session ${sessionId.substring(0, 8)}`);
+      return false;
+    }
+
+    return true;
+  }
+
+  getPendingApproval(sessionId: string): PendingApproval | undefined {
+    if (!this.hasPendingApproval(sessionId)) return undefined;
+    return this.pendingApprovals.get(sessionId);
+  }
+
+  /**
+   * Check if a message looks like a guest approval response.
+   * Used to determine if owner's message should be interpreted as approval or passed through as prompt.
+   */
+  looksLikeApprovalResponse(text: string): boolean {
+    const trimmed = text.trim().toLowerCase();
+    // Explicit approval syntax: "approve 1", "approve 2", "approve 3"
+    if (/^approve\s+[0-3]$/i.test(trimmed)) return true;
+    // Simple choices: "0", "1", "2", "3", "deny", "no"
+    if (/^[0-3]$/.test(trimmed)) return true;
+    if (trimmed === "deny" || trimmed === "no") return true;
+    return false;
+  }
+
+  async handleOwnerReply(
+    sessionId: string,
+    replyText: string,
+    threadMappingStore: ThreadMappingStore,
+    channelId: string
+  ): Promise<{ approved: boolean; post?: Post; message: string; wasApprovalResponse: boolean }> {
+    const pending = this.pendingApprovals.get(sessionId);
+    if (!pending) {
+      return { approved: false, message: "No pending approval request found.", wasApprovalResponse: false };
+    }
+
+    const trimmed = replyText.trim().toLowerCase();
+    const mapping = threadMappingStore.getBySessionId(sessionId);
+
+    const approveMatch = trimmed.match(/^approve\s+(\d)$/);
+    const effectiveChoice = approveMatch ? approveMatch[1] : trimmed;
+
+    if (effectiveChoice === "0" || effectiveChoice === "deny" || effectiveChoice === "no") {
+      this.pendingApprovals.delete(sessionId);
+      await this.mmClient.createPost(
+        channelId,
+        `❌ Request from @${pending.guestUsername} was denied.`,
+        pending.threadRootPostId
+      );
+      log.info(`[GuestApproval] Denied request from @${pending.guestUsername} in session ${sessionId.substring(0, 8)}`);
+      return { approved: false, message: "Request denied.", wasApprovalResponse: true };
+    }
+
+    if (effectiveChoice === "1") {
+      this.pendingApprovals.delete(sessionId);
+      await this.mmClient.createPost(
+        channelId,
+        `✅ Approved message from @${pending.guestUsername}.`,
+        pending.threadRootPostId
+      );
+      log.info(`[GuestApproval] Approved single message from @${pending.guestUsername} in session ${sessionId.substring(0, 8)}`);
+      return { approved: true, post: pending.originalPost, message: "Message approved.", wasApprovalResponse: true };
+    }
+
+    if (effectiveChoice === "2") {
+      this.pendingApprovals.delete(sessionId);
+      if (mapping) {
+        const approvedUsers = mapping.approvedUsers || [];
+        if (!approvedUsers.includes(pending.guestUserId)) {
+          approvedUsers.push(pending.guestUserId);
+        }
+        mapping.approvedUsers = approvedUsers;
+        threadMappingStore.update(mapping);
+      }
+      await this.mmClient.createPost(
+        channelId,
+        `✅ Approved @${pending.guestUsername} for all future messages in this thread.`,
+        pending.threadRootPostId
+      );
+      log.info(`[GuestApproval] Approved @${pending.guestUsername} for all future messages in session ${sessionId.substring(0, 8)}`);
+      return { approved: true, post: pending.originalPost, message: "User approved for thread.", wasApprovalResponse: true };
+    }
+
+    if (effectiveChoice === "3") {
+      this.pendingApprovals.delete(sessionId);
+      if (mapping) {
+        mapping.approveAllUsers = true;
+        threadMappingStore.update(mapping);
+      }
+      await this.mmClient.createPost(
+        channelId,
+        `✅ Approved all users for this thread. Anyone can now send prompts here.`,
+        pending.threadRootPostId
+      );
+      log.info(`[GuestApproval] Approved all users for session ${sessionId.substring(0, 8)}`);
+      return { approved: true, post: pending.originalPost, message: "All users approved for thread.", wasApprovalResponse: true };
+    }
+
+    // Message doesn't look like an approval response - let it pass through as a regular prompt
+    log.info(`[GuestApproval] Owner message "${replyText.slice(0, 50)}..." is not an approval response, passing through as prompt`);
+    return { approved: false, message: "Not an approval response.", wasApprovalResponse: false };
+  }
+
+  isUserApproved(
+    userId: string,
+    mapping: { approvedUsers?: string[]; approveAllUsers?: boolean; approveNextMessage?: boolean } | null,
+    teamStore?: TeamStore | null
+  ): boolean {
+    if (teamStore?.hasTeamAccess(userId)) return true;
+    if (!mapping) return false;
+    if (mapping.approveAllUsers) return true;
+    if (mapping.approveNextMessage) return true;
+    if (mapping.approvedUsers?.includes(userId)) return true;
+    return false;
+  }
+
+  consumeNextMessageApproval(
+    mapping: { approveNextMessage?: boolean } | null,
+    threadMappingStore: ThreadMappingStore
+  ): void {
+    if (mapping && mapping.approveNextMessage) {
+      (mapping as any).approveNextMessage = false;
+      threadMappingStore.update(mapping as any);
+      log.info(`[GuestApproval] Consumed one-time approveNextMessage approval`);
+    }
+  }
+
+  clearPendingApproval(sessionId: string): void {
+    this.pendingApprovals.delete(sessionId);
+  }
+
+  cleanupExpired(): number {
+    let cleaned = 0;
+    const now = Date.now();
+    
+    for (const [sessionId, pending] of this.pendingApprovals.entries()) {
+      if (now - pending.createdAt.getTime() > this.APPROVAL_TIMEOUT_MS) {
+        this.pendingApprovals.delete(sessionId);
+        cleaned++;
+      }
+    }
+    
+    return cleaned;
+  }
+}

package/src/logger.ts

@@ -0,0 +1,73 @@
+import { appendFileSync, mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+
+const LOG_FILE = process.env.MM_PLUGIN_LOG_FILE || "/tmp/opencode-mattermost-plugin.log";
+
+function ensureLogDir(): void {
+  const dir = dirname(LOG_FILE);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function formatTimestamp(): string {
+  return new Date().toISOString();
+}
+
+function serializeArg(arg: unknown): string {
+  if (arg === null || arg === undefined) {
+    return String(arg);
+  }
+  
+  // Handle Error objects specially (including Axios errors)
+  if (arg instanceof Error) {
+    const errorObj: Record<string, unknown> = {
+      message: arg.message,
+      name: arg.name,
+    };
+    
+    // Capture Axios-specific error properties
+    const axiosError = arg as { response?: { status?: number; data?: unknown }; code?: string; config?: { url?: string; method?: string } };
+    if (axiosError.response) {
+      errorObj.status = axiosError.response.status;
+      errorObj.responseData = axiosError.response.data;
+    }
+    if (axiosError.code) {
+      errorObj.code = axiosError.code;
+    }
+    if (axiosError.config) {
+      errorObj.url = axiosError.config.url;
+      errorObj.method = axiosError.config.method;
+    }
+    
+    return JSON.stringify(errorObj);
+  }
+  
+  if (typeof arg === "object") {
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }
+  
+  return String(arg);
+}
+
+function writeLog(level: string, message: string, ...args: unknown[]): void {
+  try {
+    ensureLogDir();
+    const formattedArgs = args.length > 0 
+      ? " " + args.map(serializeArg).join(" ")
+      : "";
+    const line = `[${formatTimestamp()}] [${level}] ${message}${formattedArgs}\n`;
+    appendFileSync(LOG_FILE, line);
+  } catch {}
+}
+
+export const log = {
+  info: (message: string, ...args: unknown[]) => writeLog("INFO", message, ...args),
+  error: (message: string, ...args: unknown[]) => writeLog("ERROR", message, ...args),
+  debug: (message: string, ...args: unknown[]) => writeLog("DEBUG", message, ...args),
+  warn: (message: string, ...args: unknown[]) => writeLog("WARN", message, ...args),
+};