claude-threads 1.6.2 → 1.6.3

package/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.3] - 2026-04-21
+
+### Fixed
+- **Skipped file attachments are now surfaced on session start** - When a user starts a session with an unsupported file (e.g. `.xlsx`), the bot posts the `⚠️ Some files could not be processed` warning instead of silently dropping it. The same warning now fires on the mid-thread context-prompt and worktree paths. (#325, thanks @shaders)
+- **Recognize `.har` and `.log` as text** - Both extensions come through as `application/octet-stream` via Mattermost/Slack and were previously dropped as unsupported. (#325)
+
 ## [1.6.2] - 2026-04-20
 
 ### Fixed

package/dist/index.js

@@ -59420,6 +59420,8 @@ var TEXT_FILE_EXTENSIONS = [
   ".xml",
   ".yaml",
   ".yml",
+  ".har",
+  ".log",
   ".js",
   ".ts",
   ".jsx",
@@ -59990,7 +59992,7 @@ function getUnsupportedFileSuggestion(file) {
 async function buildMessageContent(text, platform, files, debug = false) {
   const result = await processFiles(platform, files, debug);
   if (result.blocks.length === 0) {
-    return text;
+    return { content: text, skipped: result.skipped };
   }
   if (text) {
     result.blocks.push({
@@ -59998,7 +60000,12 @@ async function buildMessageContent(text, platform, files, debug = false) {
       text
     });
   }
-  return result.blocks;
+  return { content: result.blocks, skipped: result.skipped };
+}
+async function postSkippedFilesFeedback(platform, threadId, skipped) {
+  if (skipped.length === 0)
+    return;
+  await platform.createPost(formatSkippedFilesFeedback(skipped), threadId);
 }
 async function processFiles(platform, files, debug = false) {
   const blocks = [];
@@ -60052,6 +60059,18 @@ async function processFiles(platform, files, debug = false) {
   }
   return { blocks, skipped };
 }
+function formatSkippedFilesFeedback(skippedFiles) {
+  const lines = ["⚠️ **Some files could not be processed:**"];
+  for (const file of skippedFiles) {
+    let line = `- **${file.name}**: ${file.reason}`;
+    if (file.suggestion) {
+      line += ` _(${file.suggestion})_`;
+    }
+    lines.push(line);
+  }
+  return lines.join(`
+`);
+}
 function startTyping(session) {
   if (session.timers.typingTimer)
     return;
@@ -60498,20 +60517,15 @@ class MessageManager {
     }
     this.session.threadLogger?.logUserMessage(username || this.session.startedBy, message, displayName, files && files.length > 0);
     await this.prepareForUserMessage();
-    let skippedFiles = [];
-    if (files && files.length > 0) {
-      const fileResult = await processFiles(this.platform, files);
-      skippedFiles = fileResult.skipped;
-    }
     let content = message;
+    let skippedFiles = [];
     if (this.buildMessageContentCallback) {
-      content = await this.buildMessageContentCallback(message, this.platform, files);
+      const built = await this.buildMessageContentCallback(message, this.platform, files);
+      content = built.content;
+      skippedFiles = built.skipped;
     }
     this.session.claude.sendMessage(content);
-    if (skippedFiles.length > 0) {
-      const feedback = this.formatSkippedFilesFeedback(skippedFiles);
-      await this.platform.createPost(feedback, this.threadId);
-    }
+    await postSkippedFilesFeedback(this.platform, this.threadId, skippedFiles);
     this.session.lastActivityAt = new Date;
     this.session.isProcessing = true;
     this.emitSessionUpdateCallback?.({ status: "active", isTyping: true });
@@ -60519,18 +60533,6 @@ class MessageManager {
     logger.debug("User message sent to Claude");
     return true;
   }
-  formatSkippedFilesFeedback(skippedFiles) {
-    const lines = ["⚠️ **Some files could not be processed:**"];
-    for (const file of skippedFiles) {
-      let line = `- **${file.name}**: ${file.reason}`;
-      if (file.suggestion) {
-        line += ` _(${file.suggestion})_`;
-      }
-      lines.push(line);
-    }
-    return lines.join(`
-`);
-  }
   getSession() {
     return this.session;
   }
@@ -66294,9 +66296,10 @@ ${fmt.formatItalic("Claude Code restarted in the new worktree")}`);
         const contextPrefix = options2.formatContextForClaude(threadMessages, workSummary);
         const messageToSend = contextPrefix + session.firstPrompt;
         session.messageCount++;
-        const content = await options2.buildMessageContent(messageToSend, session, undefined);
+        const { content, skipped } = await options2.buildMessageContent(messageToSend, session, undefined);
         session.claude.sendMessage(content);
         options2.startTyping(session);
+        await postSkippedFilesFeedback(session.platform, session.threadId, skipped);
         sessionLog3(session).debug(`\uD83C\uDF3F Auto-included ${threadMessages.length} messages + work summary for mid-session worktree`);
       }
       session.worktreeResponsePostId = undefined;
@@ -66899,11 +66902,12 @@ async function handleContextPromptTimeout(session, ctx) {
   }
   session.messageCount++;
   const messageToSend = ctx.injectMetadataReminder(queuedPrompt, session);
-  const content = await ctx.buildMessageContent(messageToSend, session, queuedFiles);
+  const { content, skipped } = await ctx.buildMessageContent(messageToSend, session, queuedFiles);
   if (session.claude.isRunning()) {
     session.claude.sendMessage(content);
     ctx.startTyping(session);
   }
+  await postSkippedFilesFeedback(session.platform, session.threadId, skipped);
   ctx.persistSession(session);
   sessionLog5(session).debug(`\uD83E\uDDF5 Context prompt timed out, continuing without thread context`);
 }
@@ -66920,11 +66924,12 @@ async function offerContextPrompt(session, queuedPrompt, queuedFiles, ctx, exclu
       sessionLog5(session).debug(`\uD83E\uDDF5 Including work summary (no thread messages)`);
     }
     messageToSend = ctx.injectMetadataReminder(messageToSend, session);
-    const content = await ctx.buildMessageContent(messageToSend, session, queuedFiles);
+    const { content, skipped } = await ctx.buildMessageContent(messageToSend, session, queuedFiles);
     if (session.claude.isRunning()) {
       session.claude.sendMessage(content);
       ctx.startTyping(session);
     }
+    await postSkippedFilesFeedback(session.platform, session.threadId, skipped);
     return false;
   }
   if (messageCount === 1) {
@@ -66938,11 +66943,12 @@ async function offerContextPrompt(session, queuedPrompt, queuedFiles, ctx, exclu
     }
     session.messageCount++;
     messageToSend = ctx.injectMetadataReminder(messageToSend, session);
-    const content = await ctx.buildMessageContent(messageToSend, session, queuedFiles);
+    const { content, skipped } = await ctx.buildMessageContent(messageToSend, session, queuedFiles);
     if (session.claude.isRunning()) {
       session.claude.sendMessage(content);
       ctx.startTyping(session);
     }
+    await postSkippedFilesFeedback(session.platform, session.threadId, skipped);
     sessionLog5(session).debug(`\uD83E\uDDF5 Auto-included 1 message as context (thread starter)${previousWorkSummary ? " + work summary" : ""}`);
     return false;
   }
@@ -67119,7 +67125,7 @@ function createMessageManager(session, ctx) {
     }
     session.messageCount++;
     messageToSend = maybeInjectMetadataReminder(messageToSend, session, ctx, session);
-    const content = await ctx.ops.buildMessageContent(messageToSend, session.platform, undefined);
+    const { content } = await ctx.ops.buildMessageContent(messageToSend, session.platform, undefined);
     if (session.claude.isRunning()) {
       session.claude.sendMessage(content);
       ctx.ops.startTyping(session);
@@ -67425,17 +67431,19 @@ ${CHAT_PLATFORM_PROMPT}`;
     await ctx.ops.updateStickyMessage();
     return;
   }
-  const content = await ctx.ops.buildMessageContent(options2.prompt, session.platform, options2.files);
+  const { content, skipped } = await ctx.ops.buildMessageContent(options2.prompt, session.platform, options2.files);
   const messageText = typeof content === "string" ? content : options2.prompt;
   if (replyToPostId) {
     const excludePostId = triggeringPostId || replyToPostId;
     const contextOffered = await ctx.ops.offerContextPrompt(session, messageText, options2.files, excludePostId);
     if (contextOffered) {
+      await postSkippedFilesFeedback(session.platform, actualThreadId, skipped);
       return;
     }
   }
   session.messageCount++;
   claude.sendMessage(content);
+  await postSkippedFilesFeedback(session.platform, actualThreadId, skipped);
 }
 async function resumeSession(state, ctx) {
   if (!state.threadId || !state.platformId || !state.claudeSessionId || !state.workingDir) {
@@ -67620,9 +67628,7 @@ async function sendFollowUp(session, message, files, ctx, username, displayName)
   if (session.needsContextPromptOnNextMessage) {
     session.needsContextPromptOnNextMessage = false;
     await session.messageManager?.prepareForUserMessage();
-    const content = await ctx.ops.buildMessageContent(message, session.platform, files);
-    const messageText = typeof content === "string" ? content : message;
-    const contextOffered = await ctx.ops.offerContextPrompt(session, messageText, files);
+    const contextOffered = await ctx.ops.offerContextPrompt(session, message, files);
     if (contextOffered) {
       session.lastActivityAt = new Date;
       return;

package/dist/mcp/permission-server.js

@@ -15849,7 +15849,7 @@ var require_validation3 = __commonJS((exports, module) => {
 
 // node_modules/ws/lib/receiver.js
 var require_receiver = __commonJS((exports, module) => {
-  var { Writable: Writable2 } = __require("stream");
+  var { Writable } = __require("stream");
   var PerMessageDeflate = require_permessage_deflate();
   var {
     BINARY_TYPES,
@@ -15868,7 +15868,7 @@ var require_receiver = __commonJS((exports, module) => {
   var INFLATING = 5;
   var DEFER_EVENT = 6;
 
-  class Receiver extends Writable2 {
+  class Receiver extends Writable {
     constructor(options2 = {}) {
       super();
       this._allowSynchronousEvents = options2.allowSynchronousEvents !== undefined ? options2.allowSynchronousEvents : true;
@@ -16906,7 +16906,7 @@ var require_websocket = __commonJS((exports, module) => {
   var net = __require("net");
   var tls = __require("tls");
   var { randomBytes, createHash } = __require("crypto");
-  var { Duplex, Readable: Readable2 } = __require("stream");
+  var { Duplex, Readable } = __require("stream");
   var { URL: URL2 } = __require("url");
   var PerMessageDeflate = require_permessage_deflate();
   var Receiver = require_receiver();
@@ -52407,661 +52407,28 @@ function createMessageManagerEvents() {
 
 // src/operations/streaming/handler.ts
 var import_yauzl = __toESM(require_yauzl(), 1);
-import { createGunzip } from "zlib";
-import { pipeline as pipeline2 } from "stream/promises";
-import { Readable, Writable } from "stream";
 var log2 = createLogger("streaming");
 var MAX_PDF_SIZE = 32 * 1024 * 1024;
 var MAX_TEXT_FILE_SIZE = 1 * 1024 * 1024;
 var MAX_DECOMPRESSED_SIZE = 10 * 1024 * 1024;
 var MAX_ZIP_SIZE = 50 * 1024 * 1024;
 var MAX_GZIP_SIZE = 50 * 1024 * 1024;
-var MAX_ZIP_FILES = 20;
-var SUPPORTED_IMAGE_TYPES = [
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp"
-];
-var SUPPORTED_TEXT_TYPES = [
-  "text/plain",
-  "text/markdown",
-  "text/csv",
-  "text/xml",
-  "text/yaml",
-  "text/x-yaml",
-  "application/json",
-  "application/xml",
-  "application/x-yaml",
-  "application/yaml"
-];
-var TEXT_FILE_EXTENSIONS = [
-  ".txt",
-  ".md",
-  ".markdown",
-  ".json",
-  ".csv",
-  ".xml",
-  ".yaml",
-  ".yml",
-  ".js",
-  ".ts",
-  ".jsx",
-  ".tsx",
-  ".py",
-  ".rb",
-  ".go",
-  ".rs",
-  ".java",
-  ".c",
-  ".cpp",
-  ".h",
-  ".hpp",
-  ".cs",
-  ".php",
-  ".swift",
-  ".kt",
-  ".scala",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".fish",
-  ".ps1",
-  ".bat",
-  ".cmd",
-  ".html",
-  ".htm",
-  ".css",
-  ".scss",
-  ".sass",
-  ".less",
-  ".sql",
-  ".graphql",
-  ".gql",
-  ".toml",
-  ".ini",
-  ".cfg",
-  ".conf",
-  ".env",
-  ".properties",
-  ".dockerfile",
-  ".gitignore",
-  ".gitattributes",
-  ".editorconfig"
-];
-function isImageFile(file2) {
-  return file2.mimeType.startsWith("image/") && SUPPORTED_IMAGE_TYPES.includes(file2.mimeType);
-}
-function isPdfFile(file2) {
-  return file2.mimeType === "application/pdf" || file2.name.toLowerCase().endsWith(".pdf");
-}
-function isTextFile(file2) {
-  if (SUPPORTED_TEXT_TYPES.includes(file2.mimeType)) {
-    return true;
-  }
-  const lowerName = file2.name.toLowerCase();
-  return TEXT_FILE_EXTENSIONS.some((ext) => lowerName.endsWith(ext));
-}
-function isGzipFile(file2) {
-  return file2.mimeType === "application/gzip" || file2.mimeType === "application/x-gzip" || file2.name.toLowerCase().endsWith(".gz");
-}
-function isZipFile(file2) {
-  return file2.mimeType === "application/zip" || file2.mimeType === "application/x-zip-compressed" || file2.name.toLowerCase().endsWith(".zip");
-}
-function categorizeFile(file2) {
-  if (isImageFile(file2))
-    return "image";
-  if (isPdfFile(file2))
-    return "pdf";
-  if (isZipFile(file2))
-    return "zip";
-  if (isGzipFile(file2))
-    return "gzip";
-  if (isTextFile(file2))
-    return "text";
-  return "unsupported";
-}
-async function processImageFile(file2, platform, debug = false) {
-  try {
-    if (!platform.downloadFile) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: "Platform does not support file downloads"
-        }
-      };
-    }
-    const buffer = await platform.downloadFile(file2.id);
-    const base644 = buffer.toString("base64");
-    if (debug) {
-      log2.debug(`Attached image: ${file2.name} (${file2.mimeType}, ${Math.round(buffer.length / 1024)}KB)`);
-    }
-    return {
-      block: {
-        type: "image",
-        source: {
-          type: "base64",
-          media_type: file2.mimeType,
-          data: base644
-        }
-      }
-    };
-  } catch (err) {
-    log2.error(`Failed to download image ${file2.name}: ${err}`);
-    return {
-      skipped: {
-        name: file2.name,
-        reason: `Download failed: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-async function processPdfFile(file2, platform, debug = false) {
-  try {
-    if (!platform.downloadFile) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: "Platform does not support file downloads"
-        }
-      };
-    }
-    const buffer = await platform.downloadFile(file2.id);
-    if (buffer.length > MAX_PDF_SIZE) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: `PDF exceeds ${Math.round(MAX_PDF_SIZE / 1024 / 1024)}MB limit (${Math.round(buffer.length / 1024 / 1024)}MB)`,
-          suggestion: "Try splitting the PDF into smaller parts"
-        }
-      };
-    }
-    const base644 = buffer.toString("base64");
-    if (debug) {
-      log2.debug(`Attached PDF: ${file2.name} (${Math.round(buffer.length / 1024)}KB)`);
-    }
-    return {
-      block: {
-        type: "document",
-        source: {
-          type: "base64",
-          media_type: "application/pdf",
-          data: base644
-        },
-        title: file2.name
-      }
-    };
-  } catch (err) {
-    log2.error(`Failed to process PDF ${file2.name}: ${err}`);
-    return {
-      skipped: {
-        name: file2.name,
-        reason: `Processing failed: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-async function processTextFile(file2, platform, debug = false) {
-  try {
-    if (!platform.downloadFile) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: "Platform does not support file downloads"
-        }
-      };
-    }
-    const buffer = await platform.downloadFile(file2.id);
-    if (buffer.length > MAX_TEXT_FILE_SIZE) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: `File exceeds ${Math.round(MAX_TEXT_FILE_SIZE / 1024)}KB limit (${Math.round(buffer.length / 1024)}KB)`,
-          suggestion: "Try splitting the file or extracting relevant portions"
-        }
-      };
-    }
-    const content = buffer.toString("utf-8");
-    if (debug) {
-      log2.debug(`Attached text file: ${file2.name} (${Math.round(buffer.length / 1024)}KB)`);
-    }
-    const wrappedContent = formatTextFileContent(file2.name, content);
-    return {
-      block: {
-        type: "text",
-        text: wrappedContent
-      }
-    };
-  } catch (err) {
-    log2.error(`Failed to process text file ${file2.name}: ${err}`);
-    return {
-      skipped: {
-        name: file2.name,
-        reason: `Processing failed: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-function formatTextFileContent(filename, content) {
-  return `\uD83D\uDCC4 **${filename}**:
-\`\`\`
-${content}
-\`\`\``;
-}
-async function decompressGzipStream(compressedBuffer) {
-  const chunks = [];
-  let totalSize = 0;
-  const gunzip = createGunzip();
-  const source = Readable.from(compressedBuffer);
-  const collector = new Writable({
-    write(chunk, _encoding, callback) {
-      totalSize += chunk.length;
-      if (totalSize > MAX_DECOMPRESSED_SIZE) {
-        callback(new Error(`Decompressed size exceeds ${Math.round(MAX_DECOMPRESSED_SIZE / 1024 / 1024)}MB limit`));
-        return;
-      }
-      chunks.push(chunk);
-      callback();
-    }
-  });
-  await pipeline2(source, gunzip, collector);
-  return Buffer.concat(chunks);
-}
-async function processGzipFile(file2, platform, debug = false) {
-  try {
-    if (!platform.downloadFile) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: "Platform does not support file downloads"
-        }
-      };
-    }
-    if (file2.size && file2.size > MAX_GZIP_SIZE) {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: `Gzip file exceeds ${Math.round(MAX_GZIP_SIZE / 1024 / 1024)}MB limit (${Math.round(file2.size / 1024 / 1024)}MB)`,
-          suggestion: "Try compressing a smaller file or splitting the content"
-        }
-      };
-    }
-    let compressedBuffer;
-    try {
-      compressedBuffer = await platform.downloadFile(file2.id);
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      log2.error(`Failed to download gzip file ${file2.name}: ${errorMessage}`);
-      return {
-        skipped: {
-          name: file2.name,
-          reason: `Download failed: ${errorMessage}`,
-          suggestion: "Check if the file is still available and try again"
-        }
-      };
-    }
-    if (file2.size && compressedBuffer.length !== file2.size) {
-      log2.warn(`Downloaded size mismatch for ${file2.name}: expected ${file2.size}, got ${compressedBuffer.length}`);
-    }
-    let decompressedBuffer;
-    try {
-      decompressedBuffer = await decompressGzipStream(compressedBuffer);
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      let reason;
-      let suggestion;
-      if (errorMessage.includes("incorrect header check")) {
-        reason = "Invalid gzip file: the file header is corrupted or this is not a gzip file";
-        suggestion = "Verify the file is a valid gzip archive";
-      } else if (errorMessage.includes("unexpected end of file")) {
-        reason = "Incomplete gzip file: the file appears to be truncated";
-        suggestion = "Re-download the file or check if the upload completed";
-      } else if (errorMessage.includes("invalid stored block lengths")) {
-        reason = "Corrupted gzip file: the compressed data is damaged";
-        suggestion = "Try re-compressing the original file";
-      } else if (errorMessage.includes("exceeds") && errorMessage.includes("limit")) {
-        reason = errorMessage;
-        suggestion = "Try extracting only the relevant portions of the file";
-      } else {
-        reason = `Decompression failed: ${errorMessage}`;
-        suggestion = "Verify the file is a valid gzip archive";
-      }
-      return {
-        skipped: {
-          name: file2.name,
-          reason,
-          suggestion
-        }
-      };
-    }
-    const innerFilename = file2.name.toLowerCase().endsWith(".gz") ? file2.name.slice(0, -3) : file2.name;
-    const contentType = detectDecompressedContentType(decompressedBuffer, innerFilename);
-    if (debug) {
-      log2.debug(`Decompressed ${file2.name}: ${Math.round(decompressedBuffer.length / 1024)}KB, detected type: ${contentType}`);
-    }
-    if (contentType === "pdf") {
-      const base644 = decompressedBuffer.toString("base64");
-      return {
-        block: {
-          type: "document",
-          source: {
-            type: "base64",
-            media_type: "application/pdf",
-            data: base644
-          },
-          title: innerFilename
-        }
-      };
-    } else if (contentType === "text") {
-      const content = decompressedBuffer.toString("utf-8");
-      const wrappedContent = formatTextFileContent(innerFilename, content);
-      return {
-        block: {
-          type: "text",
-          text: wrappedContent
-        }
-      };
-    } else {
-      return {
-        skipped: {
-          name: file2.name,
-          reason: "Decompressed content type not supported",
-          suggestion: "Only text-based files and PDFs are supported after decompression"
-        }
-      };
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    log2.error(`Failed to process gzip file ${file2.name}: ${errorMessage}`);
-    return {
-      skipped: {
-        name: file2.name,
-        reason: `Processing failed: ${errorMessage}`,
-        suggestion: "An unexpected error occurred. Please try again or contact support if the issue persists"
-      }
-    };
-  }
-}
-async function extractZipEntry(zipfile, entry) {
-  return new Promise((resolve2, reject) => {
-    zipfile.openReadStream(entry, (err, readStream) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      if (!readStream) {
-        reject(new Error("No read stream"));
-        return;
-      }
-      const chunks = [];
-      readStream.on("data", (chunk) => chunks.push(chunk));
-      readStream.on("end", () => resolve2(Buffer.concat(chunks)));
-      readStream.on("error", reject);
-    });
-  });
-}
-async function processZipFile(file2, platform, debug = false) {
-  const blocks = [];
-  const skipped = [];
-  try {
-    if (!platform.downloadFile) {
-      return {
-        blocks: [],
-        skipped: [{
-          name: file2.name,
-          reason: "Platform does not support file downloads"
-        }]
-      };
-    }
-    if (file2.size && file2.size > MAX_ZIP_SIZE) {
-      return {
-        blocks: [],
-        skipped: [{
-          name: file2.name,
-          reason: `Zip file exceeds ${Math.round(MAX_ZIP_SIZE / 1024 / 1024)}MB limit (${Math.round(file2.size / 1024 / 1024)}MB)`
-        }]
-      };
-    }
-    const zipBuffer = await platform.downloadFile(file2.id);
-    if (debug) {
-      log2.debug(`Processing zip file ${file2.name}: ${Math.round(zipBuffer.length / 1024)}KB`);
-    }
-    const zipfile = await new Promise((resolve2, reject) => {
-      import_yauzl.default.fromBuffer(zipBuffer, { lazyEntries: true }, (err, zf) => {
-        if (err)
-          reject(err);
-        else if (!zf)
-          reject(new Error("Failed to open zip file"));
-        else
-          resolve2(zf);
-      });
-    });
-    const entries = [];
-    await new Promise((resolve2, reject) => {
-      zipfile.on("entry", (entry) => {
-        if (!entry.fileName.endsWith("/")) {
-          entries.push(entry);
-        }
-        zipfile.readEntry();
-      });
-      zipfile.on("end", resolve2);
-      zipfile.on("error", reject);
-      zipfile.readEntry();
-    });
-    if (entries.length > MAX_ZIP_FILES) {
-      zipfile.close();
-      return {
-        blocks: [],
-        skipped: [{
-          name: file2.name,
-          reason: `Zip contains too many files (${entries.length}). Maximum is ${MAX_ZIP_FILES} files.`,
-          suggestion: "Extract and upload the most relevant files individually"
-        }]
-      };
-    }
-    if (entries.length === 0) {
-      zipfile.close();
-      return {
-        blocks: [],
-        skipped: [{
-          name: file2.name,
-          reason: "Zip archive is empty"
-        }]
-      };
-    }
-    const zipfile2 = await new Promise((resolve2, reject) => {
-      import_yauzl.default.fromBuffer(zipBuffer, { lazyEntries: true }, (err, zf) => {
-        if (err)
-          reject(err);
-        else if (!zf)
-          reject(new Error("Failed to open zip file"));
-        else
-          resolve2(zf);
-      });
-    });
-    let processedCount = 0;
-    await new Promise((resolve2, reject) => {
-      zipfile2.on("entry", async (entry) => {
-        try {
-          if (entry.fileName.endsWith("/")) {
-            zipfile2.readEntry();
-            return;
-          }
-          if (entry.uncompressedSize > MAX_DECOMPRESSED_SIZE) {
-            skipped.push({
-              name: entry.fileName,
-              reason: `File exceeds ${Math.round(MAX_DECOMPRESSED_SIZE / 1024 / 1024)}MB decompressed size limit`
-            });
-            zipfile2.readEntry();
-            return;
-          }
-          const buffer = await extractZipEntry(zipfile2, entry);
-          const contentType = detectDecompressedContentType(buffer, entry.fileName);
-          if (debug) {
-            log2.debug(`Extracted ${entry.fileName}: ${Math.round(buffer.length / 1024)}KB, type: ${contentType}`);
-          }
-          if (contentType === "pdf") {
-            const base644 = buffer.toString("base64");
-            blocks.push({
-              type: "document",
-              source: {
-                type: "base64",
-                media_type: "application/pdf",
-                data: base644
-              }
-            });
-            processedCount++;
-          } else if (contentType === "text") {
-            const content = buffer.toString("utf-8");
-            const wrappedContent = formatTextFileContent(entry.fileName, content);
-            blocks.push({
-              type: "text",
-              text: wrappedContent
-            });
-            processedCount++;
-          } else {
-            skipped.push({
-              name: entry.fileName,
-              reason: "Unsupported file type inside zip",
-              suggestion: "Only text-based files and PDFs are supported"
-            });
-          }
-          zipfile2.readEntry();
-        } catch (err) {
-          skipped.push({
-            name: entry.fileName,
-            reason: `Failed to extract: ${err instanceof Error ? err.message : String(err)}`
-          });
-          zipfile2.readEntry();
-        }
-      });
-      zipfile2.on("end", resolve2);
-      zipfile2.on("error", reject);
-      zipfile2.readEntry();
-    });
-    zipfile2.close();
-    if (debug) {
-      log2.debug(`Zip ${file2.name}: processed ${processedCount} files, skipped ${skipped.length}`);
-    }
-    return { blocks, skipped };
-  } catch (err) {
-    log2.error(`Failed to process zip file ${file2.name}: ${err}`);
-    return {
-      blocks: [],
-      skipped: [{
-        name: file2.name,
-        reason: `Failed to process zip: ${err instanceof Error ? err.message : String(err)}`
-      }]
-    };
-  }
-}
-function detectDecompressedContentType(buffer, filename) {
-  if (buffer.length >= 5 && buffer.toString("ascii", 0, 5) === "%PDF-") {
-    return "pdf";
-  }
-  const lowerFilename = filename.toLowerCase();
-  if (lowerFilename.endsWith(".pdf")) {
-    return "pdf";
-  }
-  if (TEXT_FILE_EXTENSIONS.some((ext) => lowerFilename.endsWith(ext))) {
-    return "text";
-  }
-  if (buffer.length > 0) {
-    const firstChar = String.fromCharCode(buffer[0]);
-    if (firstChar === "{" || firstChar === "[") {
-      return "text";
-    }
-  }
-  try {
-    const text = buffer.toString("utf-8");
-    const printableRatio = countPrintableChars(text) / text.length;
-    if (printableRatio > 0.9) {
-      return "text";
-    }
-  } catch {}
-  return "unknown";
-}
-function countPrintableChars(text) {
-  let count = 0;
-  for (let i = 0;i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    if (code >= 32 && code <= 126 || code === 9 || code === 10 || code === 13) {
-      count++;
-    }
-  }
-  return count;
-}
-function getUnsupportedFileSuggestion(file2) {
-  const ext = file2.name.toLowerCase().split(".").pop();
-  const mime = file2.mimeType.toLowerCase();
-  if (ext === "doc" || ext === "docx" || mime.includes("msword") || mime.includes("wordprocessingml")) {
-    return "Convert to PDF for best results";
-  }
-  if (ext === "xls" || ext === "xlsx" || mime.includes("spreadsheet")) {
-    return "Export as CSV for text-based analysis";
-  }
-  if (ext === "ppt" || ext === "pptx" || mime.includes("presentation")) {
-    return "Convert to PDF for best results";
-  }
-  if (ext === "tar" || ext === "rar" || ext === "7z") {
-    return "Extract files and upload them individually, or use .zip format";
-  }
-  if (ext === "exe" || ext === "dll" || ext === "so" || ext === "dylib") {
-    return "Binary files are not supported";
-  }
-  return;
+async function postSkippedFilesFeedback(platform, threadId, skipped) {
+  if (skipped.length === 0)
+    return;
+  await platform.createPost(formatSkippedFilesFeedback(skipped), threadId);
 }
-async function processFiles(platform, files, debug = false) {
-  const blocks = [];
-  const skipped = [];
-  if (!files || files.length === 0) {
-    return { blocks, skipped };
-  }
-  for (const file2 of files) {
-    const category = categorizeFile(file2);
-    if (category === "zip") {
-      const zipResult = await processZipFile(file2, platform, debug);
-      blocks.push(...zipResult.blocks);
-      for (const s of zipResult.skipped) {
-        skipped.push(s);
-        log2.warn(`Skipped file ${s.name}: ${s.reason}`);
-      }
-      continue;
-    }
-    let result;
-    switch (category) {
-      case "image":
-        result = await processImageFile(file2, platform, debug);
-        break;
-      case "pdf":
-        result = await processPdfFile(file2, platform, debug);
-        break;
-      case "text":
-        result = await processTextFile(file2, platform, debug);
-        break;
-      case "gzip":
-        result = await processGzipFile(file2, platform, debug);
-        break;
-      case "unsupported":
-      default:
-        result = {
-          skipped: {
-            name: file2.name,
-            reason: `Unsupported file type: ${file2.mimeType}`,
-            suggestion: getUnsupportedFileSuggestion(file2)
-          }
-        };
-        break;
-    }
-    if (result.block) {
-      blocks.push(result.block);
-    }
-    if (result.skipped) {
-      skipped.push(result.skipped);
-      log2.warn(`Skipped file ${result.skipped.name}: ${result.skipped.reason}`);
+function formatSkippedFilesFeedback(skippedFiles) {
+  const lines = ["⚠️ **Some files could not be processed:**"];
+  for (const file2 of skippedFiles) {
+    let line = `- **${file2.name}**: ${file2.reason}`;
+    if (file2.suggestion) {
+      line += ` _(${file2.suggestion})_`;
     }
+    lines.push(line);
   }
-  return { blocks, skipped };
+  return lines.join(`
+`);
 }
 
 // src/operations/message-manager.ts
@@ -53495,20 +52862,15 @@ class MessageManager {
     }
     this.session.threadLogger?.logUserMessage(username || this.session.startedBy, message, displayName, files && files.length > 0);
     await this.prepareForUserMessage();
-    let skippedFiles = [];
-    if (files && files.length > 0) {
-      const fileResult = await processFiles(this.platform, files);
-      skippedFiles = fileResult.skipped;
-    }
     let content = message;
+    let skippedFiles = [];
     if (this.buildMessageContentCallback) {
-      content = await this.buildMessageContentCallback(message, this.platform, files);
+      const built = await this.buildMessageContentCallback(message, this.platform, files);
+      content = built.content;
+      skippedFiles = built.skipped;
     }
     this.session.claude.sendMessage(content);
-    if (skippedFiles.length > 0) {
-      const feedback = this.formatSkippedFilesFeedback(skippedFiles);
-      await this.platform.createPost(feedback, this.threadId);
-    }
+    await postSkippedFilesFeedback(this.platform, this.threadId, skippedFiles);
     this.session.lastActivityAt = new Date;
     this.session.isProcessing = true;
     this.emitSessionUpdateCallback?.({ status: "active", isTyping: true });
@@ -53516,18 +52878,6 @@ class MessageManager {
     logger.debug("User message sent to Claude");
     return true;
   }
-  formatSkippedFilesFeedback(skippedFiles) {
-    const lines = ["⚠️ **Some files could not be processed:**"];
-    for (const file2 of skippedFiles) {
-      let line = `- **${file2.name}**: ${file2.reason}`;
-      if (file2.suggestion) {
-        line += ` _(${file2.suggestion})_`;
-      }
-      lines.push(line);
-    }
-    return lines.join(`
-`);
-  }
   getSession() {
     return this.session;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",