claude-threads 1.6.2 → 1.7.0

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";
+async function postSkippedFilesFeedback(platform, threadId, skipped) {
+  if (skipped.length === 0)
+    return;
+  await platform.createPost(formatSkippedFilesFeedback(skipped), threadId);
 }
-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++;
+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 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 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}`);
-    }
-  }
-  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;
   }
@@ -54150,6 +53500,64 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 import { existsSync as existsSync4, readFileSync as readFileSync3, watchFile, unwatchFile, unlinkSync, statSync, readdirSync } from "fs";
 import { tmpdir } from "os";
 import { join as join3 } from "path";
+
+// src/claude/rate-limit-detector.ts
+var RATE_LIMIT_PHRASES = [
+  /usage limit reached/i,
+  /rate[_\s-]?limit[_\s-]?error/i,
+  /you have hit the rate limit/i,
+  /quota (has been )?exceeded/i,
+  /\b429\b.*(rate|limit|quota)/i
+];
+var DEFAULT_COOLDOWN_MS = 60 * 60 * 1000;
+function detectRateLimit(text, now = Date.now()) {
+  if (!text)
+    return { detected: false };
+  let matched;
+  for (const phrase of RATE_LIMIT_PHRASES) {
+    const m = text.match(phrase);
+    if (m) {
+      matched = m[0];
+      break;
+    }
+  }
+  if (!matched)
+    return { detected: false };
+  const resetAtEpochMs = extractResetAt(text, now);
+  return { detected: true, matched, resetAtEpochMs };
+}
+function extractResetAt(text, now) {
+  const relative = text.match(/(?:retry[_\s-]?after|resets?\s+in)\s+(\d+)\s*(second|minute|hour|day)s?/i);
+  if (relative) {
+    const value = parseInt(relative[1], 10);
+    const unit = relative[2].toLowerCase();
+    const unitMs = {
+      second: 1000,
+      minute: 60000,
+      hour: 3600000,
+      day: 86400000
+    };
+    return now + value * unitMs[unit];
+  }
+  const unix = text.match(/["']?reset(?:_at)?["']?\s*[:=]\s*(\d{10,13})/);
+  if (unix) {
+    const raw = parseInt(unix[1], 10);
+    return unix[1].length === 13 ? raw : raw * 1000;
+  }
+  const clock = text.match(/resets?\s+at\s+(\d{1,2}):(\d{2})\s*(utc|gmt)?/i);
+  if (clock) {
+    const hh = parseInt(clock[1], 10);
+    const mm = parseInt(clock[2], 10);
+    if (hh < 24 && mm < 60) {
+      const reference = new Date(now);
+      const target = new Date(Date.UTC(reference.getUTCFullYear(), reference.getUTCMonth(), reference.getUTCDate(), hh, mm)).getTime();
+      return target > now ? target : target + 86400000;
+    }
+  }
+  return;
+}
+
+// src/claude/cli.ts
 var log7 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
@@ -54171,6 +53579,14 @@ function cleanupBrowserBridgeSockets() {
     log7.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
+function isErrorResultEvent(event) {
+  const ev = event;
+  if (typeof ev.subtype === "string" && ev.subtype.startsWith("error"))
+    return true;
+  if (ev.is_error === true)
+    return true;
+  return false;
+}
 
 class ClaudeCli extends EventEmitter2 {
   process = null;
@@ -54180,6 +53596,7 @@ class ClaudeCli extends EventEmitter2 {
   statusFilePath = null;
   lastStatusData = null;
   stderrBuffer = "";
+  rateLimitEmitted = false;
   log;
   constructor(options2) {
     super();
@@ -54231,6 +53648,7 @@ class ClaudeCli extends EventEmitter2 {
     if (this.process)
       throw new Error("Already running");
     this.stderrBuffer = "";
+    this.rateLimitEmitted = false;
     cleanupBrowserBridgeSockets();
     const claudePath = getClaudePath();
     const args = [
@@ -54300,9 +53718,13 @@ class ClaudeCli extends EventEmitter2 {
       args.push("--settings", JSON.stringify(statusLineSettings));
     }
     this.log.debug(`Starting: ${claudePath} ${args.slice(0, 5).join(" ")}...`);
+    const childEnv = this.buildChildEnv();
+    if (this.options.account) {
+      this.log.debug(`Spawning under Claude account "${this.options.account.id}"`);
+    }
     this.process = crossSpawn(claudePath, args, {
       cwd: this.options.workingDir,
-      env: process.env,
+      env: childEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.log.debug(`Claude process spawned: pid=${this.process.pid}`);
@@ -54316,6 +53738,7 @@ class ClaudeCli extends EventEmitter2 {
         this.stderrBuffer = this.stderrBuffer.slice(-10240);
       }
       this.log.debug(`stderr: ${text.trim()}`);
+      this.maybeEmitRateLimit(text);
     });
     this.process.on("error", (err) => {
       this.log.error(`Claude error: ${err}`);
@@ -54370,9 +53793,22 @@ class ClaudeCli extends EventEmitter2 {
       try {
         const event = JSON.parse(trimmed);
         this.emit("event", event);
+        if (event.type === "result" && isErrorResultEvent(event)) {
+          this.maybeEmitRateLimit(trimmed);
+        }
       } catch {}
     }
   }
+  maybeEmitRateLimit(text) {
+    const hit = detectRateLimit(text);
+    if (!hit.detected)
+      return;
+    if (this.rateLimitEmitted)
+      return;
+    this.rateLimitEmitted = true;
+    this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
+    this.emit("rate-limit", hit);
+  }
   isRunning() {
     return this.process !== null;
   }
@@ -54441,6 +53877,22 @@ class ClaudeCli extends EventEmitter2 {
     this.process.kill("SIGINT");
     return true;
   }
+  buildChildEnv() {
+    const account = this.options.account;
+    if (!account)
+      return process.env;
+    const env = { ...process.env };
+    if (account.home) {
+      env.HOME = account.home;
+      env.USERPROFILE = account.home;
+      delete env.ANTHROPIC_API_KEY;
+      delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    } else if (account.apiKey) {
+      env.ANTHROPIC_API_KEY = account.apiKey;
+      delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    }
+    return env;
+  }
   getMcpServerPath() {
     const __filename2 = fileURLToPath3(import.meta.url);
     const __dirname4 = dirname4(__filename2);
@@ -54461,42 +53913,6 @@ class ClaudeCli extends EventEmitter2 {
   }
 }
 
-// src/update-notifier.ts
-var import_semver2 = __toESM(require_semver2(), 1);
-
-// src/operations/commands/handler.ts
-init_emoji();
-
-// src/utils/error-handler/index.ts
-var log8 = createLogger("error");
-
-// src/utils/session-log.ts
-function createSessionLog(baseLog) {
-  return (session) => {
-    if (session?.sessionId) {
-      return baseLog.forSession(session.sessionId);
-    }
-    return baseLog;
-  };
-}
-
-// src/operations/post-helpers/index.ts
-init_emoji();
-
-// src/git/worktree.ts
-import * as path from "path";
-import { homedir as homedir2 } from "os";
-var log9 = createLogger("git-wt");
-var WORKTREES_DIR = path.join(homedir2(), ".claude-threads", "worktrees");
-var METADATA_STORE_PATH = path.join(homedir2(), ".claude-threads", "worktree-metadata.json");
-
-// src/operations/post-helpers/index.ts
-var log10 = createLogger("helpers");
-var sessionLog = createSessionLog(log10);
-
-// src/claude/quick-query.ts
-var log11 = createLogger("query");
-
 // src/commands/registry.ts
 var COMMAND_REGISTRY = [
   {
@@ -55049,6 +54465,36 @@ ${avoidCommands.map((c) => `- \`!${c.command}\` - ${c.reason}`).join(`
 `)}
 `.trim();
 }
+// src/utils/error-handler/index.ts
+var log8 = createLogger("error");
+
+// src/utils/session-log.ts
+function createSessionLog(baseLog) {
+  return (session) => {
+    if (session?.sessionId) {
+      return baseLog.forSession(session.sessionId);
+    }
+    return baseLog;
+  };
+}
+
+// src/operations/post-helpers/index.ts
+init_emoji();
+
+// src/git/worktree.ts
+import * as path from "path";
+import { homedir as homedir2 } from "os";
+var log9 = createLogger("git-wt");
+var WORKTREES_DIR = path.join(homedir2(), ".claude-threads", "worktrees");
+var METADATA_STORE_PATH = path.join(homedir2(), ".claude-threads", "worktree-metadata.json");
+
+// src/operations/post-helpers/index.ts
+var log10 = createLogger("helpers");
+var sessionLog = createSessionLog(log10);
+
+// src/claude/quick-query.ts
+var log11 = createLogger("query");
+
 // src/operations/suggestions/title.ts
 var log12 = createLogger("title");
 
@@ -55066,7 +54512,11 @@ var log15 = createLogger("lifecycle");
 var sessionLog3 = createSessionLog(log15);
 var CHAT_PLATFORM_PROMPT = generateChatPlatformPrompt();
 
+// src/update-notifier.ts
+var import_semver2 = __toESM(require_semver2(), 1);
+
 // src/operations/commands/handler.ts
+init_emoji();
 var log16 = createLogger("commands");
 var sessionLog4 = createSessionLog(log16);
 // src/operations/suggestions/branch.ts