@bobfrankston/iflow 1.0.44 → 1.0.46

package/imaplib/imap-native.js

@@ -472,6 +472,14 @@ export class NativeImapClient {
                     this.buffer = this.buffer.substring(this.pendingCommand.literalBytes);
                     this.pendingCommand.literalBuffer = (this.pendingCommand.literalBuffer || "") + literal;
                     this.pendingCommand.literalBytes = undefined;
+                    // Store the literal data by its BODY key for parseFetchResponses
+                    if (this.pendingCommand.currentLiteralKey) {
+                        if (!this.pendingCommand.literals)
+                            this.pendingCommand.literals = new Map();
+                        this.pendingCommand.literals.set(this.pendingCommand.currentLiteralKey, literal);
+                        this.pendingCommand.currentLiteralKey = undefined;
+                        this.pendingCommand.currentLiteralSize = undefined;
+                    }
                     if (this.verbose)
                         console.log(`  [imap] literal consumed, ${literal.length} bytes, buffer remaining: ${this.buffer.length}`);
                     // After consuming literal, check if the NEXT part has another literal
@@ -503,8 +511,14 @@ export class NativeImapClient {
                     this.pendingCommand.literalBuffer = linePrefix;
                 }
                 this.pendingCommand.literalBytes = size;
+                // Extract the BODY section key from the prefix (e.g. BODY[], BODY[HEADER], BODY.PEEK[])
+                const keyMatch = linePrefix.match(/BODY(?:\.PEEK)?\[([^\]]*)\]\s*$/i);
+                if (keyMatch) {
+                    this.pendingCommand.currentLiteralKey = `BODY[${keyMatch[1]}]`;
+                    this.pendingCommand.currentLiteralSize = size;
+                }
                 if (this.verbose)
-                    console.log(`  [imap] literal announced: ${size} bytes, prefix: ${linePrefix.length} chars`);
+                    console.log(`  [imap] literal announced: ${size} bytes, prefix: ${linePrefix.length} chars, key: ${this.pendingCommand.currentLiteralKey || "none"}`);
                 continue;
             }
             // If we have buffered literal data, prepend it to this line (the closing part after the literal)
@@ -514,6 +528,11 @@ export class NativeImapClient {
                 this.pendingCommand.literalBuffer = undefined;
             }
             const resp = proto.parseResponseLine(fullLine);
+            // Attach accumulated literals to the response and reset for next response
+            if (this.pendingCommand?.literals?.size) {
+                resp.literals = this.pendingCommand.literals;
+                this.pendingCommand.literals = undefined;
+            }
             if (this.verbose) {
                 const display = resp.raw.length > 200 ? resp.raw.substring(0, 200) + `... (${resp.raw.length} bytes)` : resp.raw;
                 console.log(`  [imap] < [tag=${resp.tag} type=${resp.type}] ${display}`);
@@ -622,9 +641,15 @@ export class NativeImapClient {
                 msg.replyTo = env.replyTo;
                 msg.inReplyTo = env.inReplyTo;
             }
-            // Source body is in literal data (handled by literal buffering in processBuffer)
-            // For now, simplified — the literal handling needs more work for production
-            // TODO: improve literal parsing for BODY[] and BODY[HEADER]
+            // Extract body source and headers from literals tracked by processBuffer
+            if (r.literals) {
+                const source = r.literals.get("BODY[]");
+                if (source)
+                    msg.source = source;
+                const headers = r.literals.get("BODY[HEADER]");
+                if (headers)
+                    msg.headers = headers;
+            }
             messages.push(msg);
         }
         return messages;

package/imaplib/imap-protocol.d.ts

@@ -13,6 +13,8 @@ export interface ImapResponse {
     text: string;
     /** Raw line */
     raw: string;
+    /** Literal data keyed by BODY section name (e.g. "BODY[]", "BODY[HEADER]") */
+    literals?: Map<string, string>;
 }
 /** Parsed FETCH response data */
 export interface FetchData {

package/imaplib/imap-protocol.js

@@ -247,12 +247,26 @@ function decodeImapString(s) {
         return "";
     return s.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (_match, charset, encoding, text) => {
         try {
+            const cs = charset.toLowerCase().replace(/^utf8$/, "utf-8");
             if (encoding.toUpperCase() === "B") {
-                return Buffer.from(text, "base64").toString("utf-8");
+                return Buffer.from(text, "base64").toString(cs);
             }
             else {
-                // Quoted-printable
-                return text.replace(/=([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/_/g, " ");
+                // Quoted-printable: collect bytes then decode with charset
+                const decoded = text.replace(/_/g, " ");
+                const bytes = [];
+                let i = 0;
+                while (i < decoded.length) {
+                    if (decoded[i] === "=" && i + 2 < decoded.length) {
+                        bytes.push(parseInt(decoded.substring(i + 1, i + 3), 16));
+                        i += 3;
+                    }
+                    else {
+                        bytes.push(decoded.charCodeAt(i));
+                        i++;
+                    }
+                }
+                return Buffer.from(bytes).toString(cs);
             }
         }
         catch {

package/package.json

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