@bobfrankston/iflow 1.0.47 → 1.0.49

package/imaplib/imap-native.js

@@ -215,13 +215,30 @@ export class NativeImapClient {
         const tag = proto.nextTag();
         const responses = await this.sendCommand(tag, proto.listCommand(tag));
         const folders = [];
+        let unparsed = 0;
+        const listResponses = responses.filter(r => r.tag === "*" && r.type === "LIST");
+        if (listResponses.length === 0 && responses.length > 0) {
+            console.error(`  [imap] LIST returned ${responses.length} responses but none were LIST type. Types: ${responses.map(r => `${r.tag}:${r.type}`).join(", ")}`);
+            if (responses.length <= 5) {
+                for (const r of responses)
+                    console.error(`  [imap]   raw: ${JSON.stringify(r.text.substring(0, 200))}`);
+            }
+        }
         for (const r of responses) {
             if (r.tag === "*" && r.type === "LIST") {
                 const parsed = proto.parseListResponse(r.text);
-                if (parsed)
+                if (parsed) {
                     folders.push(parsed);
+                }
+                else {
+                    unparsed++;
+                    if (unparsed <= 3)
+                        console.error(`  [imap] Unparsed LIST response: ${JSON.stringify(r.text.substring(0, 200))}`);
+                }
             }
         }
+        if (unparsed > 0)
+            console.error(`  [imap] ${unparsed} LIST responses could not be parsed (${responses.length} total responses)`);
         return folders;
     }
     async getStatus(mailbox) {
@@ -468,8 +485,13 @@ export class NativeImapClient {
             // Check for literal {size}\r\n — reading exact byte count of literal data
             if (this.pendingCommand?.literalBytes != null) {
                 if (this.buffer.length >= this.pendingCommand.literalBytes) {
-                    const literal = this.buffer.substring(0, this.pendingCommand.literalBytes);
+                    let literal = this.buffer.substring(0, this.pendingCommand.literalBytes);
                     this.buffer = this.buffer.substring(this.pendingCommand.literalBytes);
+                    // For non-BODY literals (e.g. display names in ENVELOPE), wrap in quotes
+                    // so tokenizeParenList treats them as a single token
+                    if (!this.pendingCommand.currentLiteralKey) {
+                        literal = `"${literal.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, "")}"`;
+                    }
                     this.pendingCommand.literalBuffer = (this.pendingCommand.literalBuffer || "") + literal;
                     this.pendingCommand.literalBytes = undefined;
                     // Store the literal data by its BODY key for parseFetchResponses

package/imaplib/imap-protocol.js

@@ -143,13 +143,14 @@ export function parseResponseLine(line) {
 }
 /** Parse a LIST response line: * LIST (\flags) "delimiter" "path" */
 export function parseListResponse(text) {
-    // Match: LIST (flags) "delimiter" "path" or LIST (flags) "delimiter" path
-    const match = text.match(/^LIST\s+\(([^)]*)\)\s+"([^"]*)"\s+(?:"([^"]+)"|(\S+))$/i);
+    // Match: (flags) "delimiter" "path" or (flags) "delimiter" path
+    // The "LIST" prefix may or may not be present (parseResponseLine may strip it into r.type)
+    const match = text.match(/^(?:LIST\s+)?\(([^)]*)\)\s+"([^"]*)"\s+(?:"([^"]+)"|(\S+))/i);
     if (!match)
         return null;
     const flags = match[1] ? match[1].split(/\s+/).filter(Boolean) : [];
     const delimiter = match[2] || ".";
-    const path = match[3] || match[4] || "";
+    const path = (match[3] || match[4] || "").replace(/\r?\n$/, "");
     return { flags, delimiter, path };
 }
 /** Parse STATUS response: * STATUS "mailbox" (MESSAGES n UIDNEXT n ...) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/iflow",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "IMAP client wrapper library",
   "main": "index.js",
   "types": "index.ts",